home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume2 / languags / dasm20.2 < prev    next >
Text File  |  1988-10-26  |  63KB  |  2,591 lines
  1. Path: wucfua!wucs1!uunet!wyse!vsi1!ames!mailrus!ulowell!page
  2. From: page@swan.ulowell.edu (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v02i028:  dasm - small systems cross assembler V2.0, Part02/03
  5. Message-ID: <9879@swan.ulowell.edu>
  6. Date: 26 Oct 88 17:22:29 GMT
  7. Organization: University of Lowell, Computer Science Dept.
  8. Lines: 2580
  9. Approved: page@swan.ulowell.edu
  10.  
  11. Submitted-by: dillon@cory.berkeley.edu (Matt Dillon)
  12. Posting-number: Volume 2, Issue 28
  13. Archive-name: languages/dasm20.2
  14.  
  15. # This is a shell archive.  Remove anything before this line
  16. # then unpack it by saving it in a file and typing "sh file"
  17. # (Files unpacked will be owned by you and have default permissions).
  18. # This archive contains the following files:
  19. #    src/asm.h
  20. #    src/ops.c
  21. #    src/mne6502.c
  22. #    src/mne6811.c
  23. #    src/main.c
  24. #
  25. if `test ! -d src`
  26. then
  27.   mkdir src
  28.   echo "mkdir src"
  29. fi
  30. if `test ! -s src/asm.h`
  31. then
  32. echo "writing src/asm.h"
  33. cat > src/asm.h << '\Rogue\Monster\'
  34.  
  35. /*
  36.  *  ASM65.H
  37.  *
  38.  *  (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  39.  *
  40.  *  Structures and definitions
  41.  */
  42.  
  43. #include <stdio.h>
  44.  
  45. #ifdef UNIX
  46. #define bmov(s,d,n) bcopy(s,d,n)
  47. #define bset(s,n,c) xbset(s,n,c)
  48. #endif
  49.  
  50. #ifdef IBM
  51. #define bmov(s,d,n) movmem(s,d,(int)n)
  52. #define bset(s,n,c) setmem(s,(int)n,(int)c)
  53. #define bzero(s,n)  setmem(s,(int)n,0)
  54. #endif
  55.  
  56. #ifdef IBM
  57. typedef char     ubyte;
  58. typedef unsigned uword;
  59. typedef long     ulong;
  60. typedef int     void;
  61. #else
  62. typedef unsigned char ubyte;
  63. typedef unsigned short uword;
  64. typedef unsigned long ulong;
  65. #endif
  66.  
  67. #define MNE        struct _MNE
  68. #define MACRO        struct _MACRO
  69. #define INCFILE     struct _INCFILE
  70. #define REPLOOP     struct _REPLOOP
  71. #define IFSTACK     struct _IFSTACK
  72. #define SEGMENT     struct _SEGMENT
  73. #define SYMBOL        struct _SYMBOL
  74. #define STRLIST     struct _STRLIST
  75.  
  76. #define DEFORGFILL  255
  77. #define SHASHSIZE   1024
  78. #define MHASHSIZE   1024
  79. #define SHASHAND    0x03FF
  80. #define MHASHAND    0x03FF
  81. #define ALLOCSIZE   16384
  82. #define MAXMACLEVEL 32
  83. #define TAB        9
  84.  
  85. #define OUTFORM1    0
  86. #define OUTFORM2    1
  87. #define OUTFORM3    2
  88.  
  89. #define AM_IMP        0        /*    implied         */
  90. #define AM_IMM8     1        /*    immediate 8  bits   */
  91. #define AM_IMM16    2        /*    immediate 16 bits   */
  92. #define AM_BYTEADR    3        /*    address 8 bits        */
  93. #define AM_BYTEADRX    4        /*    address 16 bits     */
  94. #define AM_BYTEADRY    5        /*    relative 8 bits     */
  95. #define AM_WORDADR    6        /*    index x 0 bits        */
  96. #define AM_WORDADRX    7        /*    index x 8 bits        */
  97. #define AM_WORDADRY    8        /*    index x 16 bits     */
  98. #define AM_REL        9        /*    bit inst. special   */
  99. #define AM_INDBYTEX    10        /*    bit-bra inst. spec. */
  100. #define AM_INDBYTEY    11        /*    index y 0 bits        */
  101. #define AM_INDWORD    12        /*    index y 8 bits        */
  102. #define AM_0X        13        /*    index x 0 bits        */
  103. #define AM_0Y        14        /*    index y 0 bits        */
  104. #define AM_BITMOD    15        /*    ind addr 8 bits     */
  105. #define AM_BITBRAMOD    16        /*    ind addr 16 bits    */
  106. #define NUMOC        17
  107.  
  108. #define AF_IMP        (1L << 0 )
  109. #define AF_IMM8     (1L << 1 )
  110. #define AF_IMM16    (1L << 2 )
  111. #define AF_BYTEADR    (1L << 3 )
  112. #define AF_BYTEADRX    (1L << 4 )
  113. #define AF_BYTEADRY    (1L << 5 )
  114. #define AF_WORDADR    (1L << 6 )
  115. #define AF_WORDADRX    (1L << 7 )
  116. #define AF_WORDADRY    (1L << 8 )
  117. #define AF_REL        (1L << 9 )
  118. #define AF_INDBYTEX    (1L << 10)
  119. #define AF_INDBYTEY    (1L << 11)
  120. #define AF_INDWORD    (1L << 12)
  121. #define AF_0X        (1L << 13)
  122. #define AF_0Y        (1L << 14)
  123. #define AF_BITMOD    (1L << 15)
  124. #define AF_BITBRAMOD    (1L << 16)
  125.  
  126. #define AM_SYMBOL    (NUMOC+0)
  127. #define AM_EXPLIST    (NUMOC+1)
  128.  
  129. #define AM_BYTE     AM_BYTEADR
  130. #define AM_WORD     AM_WORDADR
  131. #define AM_LONG     (NUMOC+2)
  132. #define AM_BSS        (NUMOC+3)
  133.  
  134.  
  135. STRLIST {
  136.     STRLIST *next;
  137.     ubyte   buf[4];
  138. };
  139.  
  140. #define MF_IF        0x04
  141. #define MF_MACRO    0x08
  142. #define MF_MASK     0x10    /*  has mask argument (byte)    */
  143. #define MF_REL        0x20    /*  has rel. address (byte)     */
  144. #define MF_IMOD     0x40    /*  instruction byte mod.    */
  145.  
  146. MNE {
  147.     MNE     *next;        /*    hash        */
  148.     void    (*vect)();      /*  dispatch        */
  149.     char    *name;        /*    actual name    */
  150.     ubyte   flags;        /*    special flags    */
  151.     ulong   okmask;
  152.     uword   opcode[NUMOC];  /*    hex codes, byte or word (>xFF) opcodes  */
  153. };
  154.  
  155. MACRO {
  156.     MACRO   *next;
  157.     void    (*vect)();
  158.     ubyte   *name;
  159.     ubyte   flags;
  160.     STRLIST *strlist;
  161. };
  162.  
  163. #define INF_MACRO   0x01
  164.  
  165. INCFILE {
  166.     INCFILE *next;  /*    previously pushed context   */
  167.     ubyte   *name;  /*    file name            */
  168.     FILE    *fi;    /*    file handle            */
  169.     ulong   lineno; /*    line number in file        */
  170.     ubyte   flags;  /*    flags (macro)               */
  171.  
  172.     /*  Only if Macro   */
  173.  
  174.     STRLIST *args;    /*  arguments to macro        */
  175.     STRLIST *strlist;    /*  current string list     */
  176.     ulong   saveidx;    /*  save localindex        */
  177. };
  178.  
  179. #define RPF_UNKNOWN 0x01    /*    value unknown        */
  180.  
  181. REPLOOP {
  182.     REPLOOP *next;  /*    previously pushed context   */
  183.     ulong   count;  /*    repeat count            */
  184.     ulong   seek;   /*    seek to top of repeat        */
  185.     ulong   lineno; /*    line number of line before  */
  186.     INCFILE *file;  /*    which include file are we in*/
  187.     ubyte   flags;
  188. };
  189.  
  190. #define IFF_UNKNOWN 0x01    /*    value unknown        */
  191. #define IFF_BASE    0x04
  192.  
  193. IFSTACK {
  194.     IFSTACK *next;  /*    previous IF            */
  195.     INCFILE *file;  /*    which include file are we in*/
  196.     ubyte   flags;
  197.     ubyte   true;   /*    1 if true, 0 if false            */
  198.     ubyte   acctrue;/*    accumulatively true (not incl this one) */
  199. };
  200.  
  201. #define SF_UNKNOWN  0x01    /*    ORG unknown            */
  202. #define SF_REF        0x04    /*    ORG referenced            */
  203. #define SF_BSS        0x10    /*    uninitialized area (U flag)     */
  204. #define SF_RORG     0x20    /*    relocatable origin active    */
  205.  
  206. SEGMENT {
  207.     SEGMENT *next;  /*    next segment in segment list    */
  208.     ubyte   *name;  /*    name of segment         */
  209.     ubyte   flags;  /*    for ORG             */
  210.     ubyte   rflags; /*    for RORG            */
  211.     ulong   org;    /*    current org            */
  212.     ulong   rorg;   /*    current rorg            */
  213.     ulong   initorg;
  214.     ulong   initrorg;
  215.     ubyte   initflags;
  216.     ubyte   initrflags;
  217. };
  218.  
  219. #define SYM_UNKNOWN 0x01    /*    value unknown        */
  220. #define SYM_REF     0x04    /*    referenced        */
  221. #define SYM_STRING  0x08    /*    result is a string    */
  222. #define SYM_SET     0x10    /*    SET instruction used    */
  223. #define SYM_MACRO   0x20    /*    symbol is a macro    */
  224. #define SYM_MASREF  0x40    /*    master reference    */
  225.  
  226. SYMBOL {
  227.     SYMBOL  *next;    /*  next symbol in hash list        */
  228.     ubyte   *name;    /*  symbol name or string if expr.  */
  229.     ubyte   *string;    /*  if symbol is actually a string  */
  230.     ubyte   flags;    /*  flags                */
  231.     ubyte   addrmode;    /*  addressing mode (expressions)   */
  232.     ulong   value;    /*  current value            */
  233.     uword   namelen;    /*  name length             */
  234. };
  235.  
  236. extern SYMBOL    *SHash[];
  237. extern MNE    *MHash[];
  238. extern INCFILE    *Incfile;
  239. extern REPLOOP    *Reploop;
  240. extern SEGMENT    *Seglist;
  241. extern IFSTACK    *Ifstack;
  242.  
  243. extern SEGMENT    *Csegment;  /*    current segment */
  244. extern ubyte    *Av[];
  245. extern ubyte    Avbuf[];
  246. extern uword    Adrbytes[];
  247. extern uword    Cvt[];
  248. extern uword    Opsize[];
  249. extern uword    Mnext;        /*    mnemonic extension  */
  250. extern uword    Mlevel;
  251.  
  252. extern void    fseek();
  253. extern long    ftell();
  254.  
  255. extern ubyte    *malloc(), *zmalloc(), *strcpy(), *permalloc();
  256. extern ubyte    *sftos();
  257. extern SYMBOL    *allocsymbol();
  258. extern ubyte    Xtrace;
  259. extern ubyte    Xdebug;
  260. extern ubyte    MsbOrder;
  261. extern ubyte    Outputformat;
  262. extern ulong    Redo, Redo_why, Redo_eval;
  263. extern ulong    Localindex, Lastlocalindex;
  264.  
  265. extern ubyte    F_format;
  266. extern ubyte    F_verbose;
  267. extern char    *F_outfile;
  268. extern char    *F_listfile;
  269. extern char    *F_symfile;
  270. extern char    *F_temppath;
  271. extern FILE    *FI_listfile;
  272. extern FILE    *FI_temp;
  273. extern ubyte    Fisclear;
  274. extern ulong    Plab, Pflags;
  275. extern char    Inclevel;
  276. extern char    ListMode;
  277. extern ulong    Processor;
  278.  
  279. extern SYMBOL    *findsymbol(), *createsymbol(), *eval();
  280.  
  281. extern uword _fmode;
  282. extern ulong  CheckSum;
  283.  
  284. \Rogue\Monster\
  285. else
  286.   echo "will not over write src/asm.h"
  287. fi
  288. if [ `wc -c src/asm.h | awk '{printf $1}'` -ne 6790 ]
  289. then
  290. echo `wc -c src/asm.h | awk '{print "Got " $1 ", Expected " 6790}'`
  291. fi
  292. if `test ! -s src/ops.c`
  293. then
  294. echo "writing src/ops.c"
  295. cat > src/ops.c << '\Rogue\Monster\'
  296.  
  297. /*
  298.  *  OPS.C
  299.  *
  300.  *  (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  301.  *
  302.  *  Handle mnemonics and pseudo ops
  303.  *
  304.  */
  305.  
  306. #include "asm.h"
  307.  
  308. ubyte    Gen[256];
  309. ubyte    OrgFill = DEFORGFILL;
  310. short    Glen;
  311.  
  312. extern void generate();
  313. extern void genfill();
  314. extern void pushif();
  315.  
  316. /*
  317.  *  An opcode modifies the SEGMENT flags in the following ways:
  318.  */
  319.  
  320. void
  321. v_processor(str)
  322. register char *str;
  323. {
  324.     extern MNE    Mne6502[];
  325.     extern MNE    Mne6803[];
  326.     extern MNE    MneHD6303[];
  327.     extern MNE    Mne68705[];
  328.     extern MNE    Mne68HC11[];
  329.     register short none = 1;
  330.     static int    called;
  331.  
  332.     if (called)
  333.     return;
  334.     called = 1;
  335.     if (strcmp(str,"6502") == 0) {
  336.     addhashtable(Mne6502);
  337.     MsbOrder = 0;       /*  lsb,msb */
  338.     Processor = 6502;
  339.     }
  340.     if (strcmp(str,"6803") == 0) {
  341.     addhashtable(Mne6803);
  342.     MsbOrder = 1;       /*  msb,lsb */
  343.     Processor = 6803;
  344.     }
  345.     if (strcmp(str,"HD6303") == 0 || strcmp(str, "hd6303") == 0) {
  346.     addhashtable(Mne6803);
  347.     addhashtable(MneHD6303);
  348.     MsbOrder = 1;       /*  msb,lsb */
  349.     Processor = 6303;
  350.     }
  351.     if (strcmp(str,"68705") == 0) {
  352.     addhashtable(Mne68705);
  353.     MsbOrder = 1;       /*  msb,lsb */
  354.     Processor = 68705;
  355.     }
  356.     if (strcmp(str,"68HC11") == 0 || strcmp(str, "68hc11") == 0) {
  357.     addhashtable(Mne68HC11);
  358.     MsbOrder = 1;       /*  msb,lsb */
  359.     Processor = 6811;
  360.     }
  361.     if (!Processor)
  362.     asmerr(20,1);
  363. }
  364.  
  365. #define badcode(mne,adrmode)  (!(mne->okmask & (1L << adrmode)))
  366.  
  367. void
  368. v_mnemonic(str,mne)
  369. register MNE *mne;
  370. ubyte *str;
  371. {
  372.     register uword addrmode;
  373.     register SYMBOL *sym;
  374.     register uword opcode;
  375.     short opidx;
  376.     SYMBOL *symbase;
  377.     short   opsize;
  378.  
  379.     Csegment->flags |= SF_REF;
  380.     programlabel();
  381.     symbase = eval(str);
  382.  
  383.     if (Xtrace)
  384.     printf("PC: %04lx  MNE: %s  addrmode: %d  ", Csegment->org, mne->name, symbase->addrmode);
  385.     for (sym = symbase; sym; sym = sym->next) {
  386.     if (sym->flags & SYM_UNKNOWN) {
  387.         ++Redo;
  388.         Redo_why |= 1 << 0;
  389.     }
  390.     }
  391.     sym = symbase;
  392.  
  393.     if (mne->flags & MF_IMOD) {
  394.     if (sym->next) {
  395.         sym->addrmode = AM_BITMOD;
  396.         if ((mne->flags & MF_REL) && sym->next)
  397.         sym->addrmode = AM_BITBRAMOD;
  398.     }
  399.     }
  400.     addrmode = sym->addrmode;
  401.     if ((sym->flags & SYM_UNKNOWN) || sym->value >= 0x100)
  402.     opsize = 2;
  403.     else
  404.     opsize = (sym->value) ? 1 : 0;
  405.     while (badcode(mne,addrmode) && Cvt[addrmode])
  406.     addrmode = Cvt[addrmode];
  407.     if (Xtrace)
  408.     printf("mnemask: %08lx adrmode: %d  Cvt[am]: %d\n", mne->okmask, addrmode, Cvt[addrmode]);
  409.     if (badcode(mne,addrmode)) {
  410.     asmerr(5,0);
  411.     freesymbollist(symbase);
  412.     return;
  413.     }
  414.     if (Mnext >= 0 && Mnext < NUMOC) {          /*  Force   */
  415.     addrmode = Mnext;
  416.     if (badcode(mne,addrmode)) {
  417.         asmerr(19,0);
  418.         freesymbollist(symbase);
  419.         return;
  420.     }
  421.     }
  422.     if (Xtrace)
  423.     printf("final addrmode = %d\n", addrmode);
  424.     while (opsize > Opsize[addrmode]) {
  425.     if (Cvt[addrmode] == 0 || badcode(mne,Cvt[addrmode])) {
  426.         if (sym->flags & SYM_UNKNOWN)
  427.         break;
  428.         asmerr(14,0);
  429.         break;
  430.     }
  431.     addrmode = Cvt[addrmode];
  432.     }
  433.     opcode = mne->opcode[addrmode];
  434.     opidx = 1 + (opcode > 0xFF);
  435.     if (opidx == 2) {
  436.     Gen[0] = opcode >> 8;
  437.     Gen[1] = opcode;
  438.     } else {
  439.     Gen[0] = opcode;
  440.     }
  441.     switch(addrmode) {
  442.     case AM_BITMOD:
  443.     sym = symbase->next;
  444.     if (!(sym->flags & SYM_UNKNOWN) && sym->value >= 0x100)
  445.         asmerr(14,0);
  446.     Gen[opidx++] = sym->value;
  447.     if (!(symbase->flags & SYM_UNKNOWN)) {
  448.         if (symbase->value > 7)
  449.         asmerr(15,0);
  450.         else
  451.         Gen[0] += symbase->value << 1;
  452.     }
  453.     break;
  454.     case AM_BITBRAMOD:
  455.     if (!(symbase->flags & SYM_UNKNOWN)) {
  456.         if (symbase->value > 7)
  457.         asmerr(15,0);
  458.         else
  459.         Gen[0] += symbase->value << 1;
  460.     }
  461.     sym = symbase->next;
  462.     if (!(sym->flags & SYM_UNKNOWN) && sym->value >= 0x100)
  463.         asmerr(14,0);
  464.     Gen[opidx++] = sym->value;
  465.     sym = sym->next;
  466.     break;
  467.     case AM_REL:
  468.     break;
  469.     default:
  470.     if (Opsize[addrmode] > 0)
  471.         Gen[opidx++] = sym->value;
  472.     if (Opsize[addrmode] == 2) {
  473.         if (MsbOrder) {
  474.         Gen[opidx-1] = sym->value >> 8;
  475.         Gen[opidx++] = sym->value;
  476.         } else {
  477.         Gen[opidx++] = sym->value >> 8;
  478.         }
  479.     }
  480.     sym = sym->next;
  481.     break;
  482.     }
  483.     if (mne->flags & MF_MASK) {
  484.     if (sym) {
  485.         if (!(sym->flags & SYM_UNKNOWN) && sym->value >= 0x100)
  486.         asmerr(14,0);
  487.         Gen[opidx] = sym->value;
  488.         sym = sym->next;
  489.     } else {
  490.         asmerr(16, 1);
  491.     }
  492.     ++opidx;
  493.     }
  494.     if ((mne->flags & MF_REL) || addrmode == AM_REL) {
  495.     ++opidx;        /*  to end of instruction   */
  496.     if (!sym)
  497.         asmerr(16, 1);
  498.     else
  499.     if (!(sym->flags & SYM_UNKNOWN)) {
  500.         long    pc;
  501.         ubyte   pcf;
  502.         long    dest;
  503.         pc = (Csegment->flags & SF_RORG) ? Csegment->rorg : Csegment->org;
  504.         pcf= (Csegment->flags & SF_RORG) ? Csegment->rflags : Csegment->flags;
  505.         if ((pcf & 3) == 0) {
  506.         dest = sym->value - pc - opidx;
  507.         if (dest >= 128 || dest < -128)
  508.             asmerr(10,0);
  509.         }
  510.         Gen[opidx-1] = dest & 0xFF;     /*    byte before end of inst.    */
  511.     }
  512.     }
  513.     Glen = opidx;
  514.     generate();
  515.     freesymbollist(symbase);
  516. }
  517.  
  518.  
  519. v_trace(str)
  520. char *str;
  521. {
  522.     if (str[1] == 'n')
  523.     Xtrace = 1;
  524.     else
  525.     Xtrace = 0;
  526. }
  527.  
  528. v_list(str)
  529. char *str;
  530. {
  531.     programlabel();
  532.  
  533.     Glen = 0;        /*  Only so outlist() works */
  534.     if (strncmp(str, "off", 2) == 0 || strncmp(str, "OFF", 2) == 0)
  535.     ListMode = 0;
  536.     else
  537.     ListMode = 1;
  538. }
  539.  
  540. v_include(str)
  541. char *str;
  542. {
  543.     char    *buf;
  544.  
  545.     programlabel();
  546.     if (*str == '\"') {
  547.     buf = (char *)malloc(strlen(str));
  548.     strcpy(buf, str+1);
  549.     for (str = buf; *str && *str != '\"'; ++str);
  550.     *str = 0;
  551.     pushinclude(buf);
  552.     free(buf);
  553.     } else {
  554.     pushinclude(str);
  555.     }
  556. }
  557.  
  558. v_seg(str)
  559. char *str;
  560. {
  561.     register SEGMENT *seg;
  562.  
  563.     for (seg = Seglist; seg; seg = seg->next) {
  564.     if (strcmp(str, seg->name) == 0) {
  565.         Csegment = seg;
  566.         programlabel();
  567.         return;
  568.     }
  569.     }
  570.     Csegment = seg = (SEGMENT *)zmalloc(sizeof(SEGMENT));
  571.     seg->next = Seglist;
  572.     seg->name = strcpy(malloc(strlen(str)+1), str);
  573.     seg->flags= seg->rflags = seg->initflags = seg->initrflags = SF_UNKNOWN;
  574.     Seglist = seg;
  575.     if (Mnext == AM_BSS)
  576.     seg->flags |= SF_BSS;
  577.     programlabel();
  578. }
  579.  
  580. v_hex(str)
  581. register char *str;
  582. {
  583.     register int i;
  584.     register int result;
  585.  
  586.     programlabel();
  587.     Glen = 0;
  588.     for (i = 0; str[i]; ++i) {
  589.     if (str[i] == ' ')
  590.         continue;
  591.     result = (gethexdig(str[i]) << 4) + gethexdig(str[i+1]);
  592.     if (str[++i] == 0)
  593.         break;
  594.     Gen[Glen++] = result;
  595.     }
  596.     generate();
  597. }
  598.  
  599. gethexdig(c)
  600. {
  601.     if (c >= '0' && c <= '9')
  602.     return(c - '0');
  603.     if (c >= 'a' && c <= 'f')
  604.     return(c - 'a' + 10);
  605.     if (c >= 'A' && c <= 'F')
  606.     return(c - 'A' + 10);
  607.     asmerr(0,0);
  608.     puts("(Must be a valid hex digit)");
  609.     if (F_listfile)
  610.     fputs("(Must be a valid hex digit)\n", FI_listfile);
  611.     return(0);
  612. }
  613.  
  614. v_err()
  615. {
  616.     programlabel();
  617.     asmerr(11, 1);
  618.     exit(1);
  619. }
  620.  
  621. v_dc(str,mne)
  622. char *str;
  623. MNE *mne;
  624. {
  625.     register SYMBOL *sym;
  626.     register SYMBOL *tmp;
  627.     register ulong  value;
  628.     char *macstr;
  629.     char vmode = 0;
  630.  
  631.     Glen = 0;
  632.     programlabel();
  633.     if (mne->name[1] == 'v') {
  634.     register short i;
  635.     vmode = 1;
  636.     for (i = 0; str[i] && str[i] != ' '; ++i);
  637.     tmp = findsymbol(str, i);
  638.     str += i;
  639.     if (tmp == NULL) {
  640.         puts("EQM label not found");
  641.         return;
  642.     }
  643.     if (tmp->flags & SYM_MACRO) {
  644.         macstr = (char *)tmp->string;
  645.     } else {
  646.         puts("must specify EQM label for DV");
  647.         return;
  648.     }
  649.     }
  650.     sym = eval(str);
  651.     for (; sym; sym = sym->next) {
  652.     value = sym->value;
  653.     if (sym->flags & SYM_UNKNOWN) {
  654.         ++Redo;
  655.         Redo_why |= (1 << 2);
  656.     }
  657.     if (sym->flags & SYM_STRING) {
  658.         register ubyte *ptr = (ubyte *)sym->string;
  659.         while (value = *ptr) {
  660.         if (vmode) {
  661.             setspecial(value, 0);
  662.             tmp = eval(macstr);
  663.             value = tmp->value;
  664.             if (tmp->flags & SYM_UNKNOWN) {
  665.             ++Redo;
  666.             Redo_why |= (1 << 3);
  667.             }
  668.             freesymbollist(tmp);
  669.         }
  670.         switch(Mnext) {
  671.         default:
  672.         case AM_BYTE:
  673.             Gen[Glen++] = value & 0xFF;
  674.             break;
  675.         case AM_WORD:
  676.             if (MsbOrder) {
  677.             Gen[Glen++] = (value >> 8) & 0xFF;
  678.             Gen[Glen++] = value & 0xFF;
  679.             } else {
  680.             Gen[Glen++] = value & 0xFF;
  681.             Gen[Glen++] = (value >> 8) & 0xFF;
  682.             }
  683.             break;
  684.         case AM_LONG:
  685.             if (MsbOrder) {
  686.             Gen[Glen++] = (value >> 24)& 0xFF;
  687.             Gen[Glen++] = (value >> 16)& 0xFF;
  688.             Gen[Glen++] = (value >> 8) & 0xFF;
  689.             Gen[Glen++] = value & 0xFF;
  690.             } else {
  691.             Gen[Glen++] = value & 0xFF;
  692.             Gen[Glen++] = (value >> 8) & 0xFF;
  693.             Gen[Glen++] = (value >> 16)& 0xFF;
  694.             Gen[Glen++] = (value >> 24)& 0xFF;
  695.             }
  696.             break;
  697.         }
  698.         ++ptr;
  699.         }
  700.     } else {
  701.         if (vmode) {
  702.         setspecial(value, sym->flags);
  703.         tmp = eval(macstr);
  704.         value = tmp->value;
  705.         if (tmp->flags & SYM_UNKNOWN) {
  706.             ++Redo;
  707.             Redo_why |= 1 << 4;
  708.         }
  709.         freesymbollist(tmp);
  710.         }
  711.         switch(Mnext) {
  712.         default:
  713.         case AM_BYTE:
  714.         Gen[Glen++] = value & 0xFF;
  715.         break;
  716.         case AM_WORD:
  717.         if (MsbOrder) {
  718.             Gen[Glen++] = (value >> 8) & 0xFF;
  719.             Gen[Glen++] = value & 0xFF;
  720.         } else {
  721.             Gen[Glen++] = value & 0xFF;
  722.             Gen[Glen++] = (value >> 8) & 0xFF;
  723.         }
  724.         break;
  725.         case AM_LONG:
  726.         if (MsbOrder) {
  727.             Gen[Glen++] = (value >> 24)& 0xFF;
  728.             Gen[Glen++] = (value >> 16)& 0xFF;
  729.             Gen[Glen++] = (value >> 8) & 0xFF;
  730.             Gen[Glen++] = value & 0xFF;
  731.         } else {
  732.             Gen[Glen++] = value & 0xFF;
  733.             Gen[Glen++] = (value >> 8) & 0xFF;
  734.             Gen[Glen++] = (value >> 16)& 0xFF;
  735.             Gen[Glen++] = (value >> 24)& 0xFF;
  736.         }
  737.         break;
  738.         }
  739.     }
  740.     }
  741.     generate();
  742.     freesymbollist(sym);
  743. }
  744.  
  745. v_ds(str)
  746. char *str;
  747. {
  748.     register SYMBOL *sym;
  749.     int mult = 1;
  750.     long filler = 0;
  751.  
  752.     if (Mnext == AM_WORD)
  753.     mult = 2;
  754.     if (Mnext == AM_LONG)
  755.     mult = 4;
  756.     programlabel();
  757.     if (sym = eval(str)) {
  758.     if (sym->next)
  759.         filler = sym->next->value;
  760.     if (sym->flags & SYM_UNKNOWN) {
  761.         ++Redo;
  762.         Redo_why |= 1 << 5;
  763.     } else {
  764.         if (sym->next && sym->next->flags & SYM_UNKNOWN) {
  765.         ++Redo;
  766.         Redo_why |= 1 << 5;
  767.         }
  768.         genfill(filler, sym->value, mult);
  769.     }
  770.     freesymbollist(sym);
  771.     }
  772. }
  773.  
  774. v_org(str)
  775. char *str;
  776. {
  777.     register SYMBOL *sym;
  778.  
  779.     sym = eval(str);
  780.     Csegment->org = sym->value;
  781.     if (sym->flags & SYM_UNKNOWN)
  782.     Csegment->flags |= SYM_UNKNOWN;
  783.     else
  784.     Csegment->flags &= ~SYM_UNKNOWN;
  785.     if (Csegment->initflags & SYM_UNKNOWN) {
  786.     Csegment->initorg = sym->value;
  787.     Csegment->initflags = sym->flags;
  788.     }
  789.     if (sym->next) {
  790.     OrgFill = sym->next->value;
  791.     if (sym->next->flags & SYM_UNKNOWN)
  792.         asmerr(18,1);
  793.     }
  794.     programlabel();
  795.     freesymbollist(sym);
  796. }
  797.  
  798. v_rorg(str)
  799. char *str;
  800. {
  801.     register SYMBOL *sym = eval(str);
  802.  
  803.     Csegment->flags |= SF_RORG;
  804.     if (sym->addrmode != AM_IMP) {
  805.     Csegment->rorg = sym->value;
  806.     if (sym->flags & SYM_UNKNOWN)
  807.         Csegment->rflags |= SYM_UNKNOWN;
  808.     else
  809.         Csegment->rflags &= ~SYM_UNKNOWN;
  810.     if (Csegment->initrflags & SYM_UNKNOWN) {
  811.         Csegment->initrorg = sym->value;
  812.         Csegment->initrflags = sym->flags;
  813.     }
  814.     }
  815.     programlabel();
  816.     freesymbollist(sym);
  817. }
  818.  
  819. v_rend()
  820. {
  821.     programlabel();
  822.     Csegment->flags &= ~SF_RORG;
  823. }
  824.  
  825. v_align(str)
  826. char *str;
  827. {
  828.     SYMBOL *sym = eval(str);
  829.     ubyte   fill = 0;
  830.     ubyte   rorg = Csegment->flags & SF_RORG;
  831.  
  832.     if (rorg)
  833.     Csegment->rflags |= SF_REF;
  834.     else
  835.     Csegment->flags |= SF_REF;
  836.     if (sym->next) {
  837.     if (sym->next->flags & SYM_UNKNOWN) {
  838.         ++Redo;
  839.         Redo_why |= 1 << 6;
  840.     } else {
  841.         fill = sym->value;
  842.     }
  843.     }
  844.     if (rorg) {
  845.     if ((Csegment->rflags | sym->flags) & SYM_UNKNOWN) {
  846.         ++Redo;
  847.         Redo_why |= 1 << 7;
  848.     } else {
  849.         register long n = sym->value - (Csegment->rorg % sym->value);
  850.         if (n != sym->value)
  851.         genfill(fill, n, 1);
  852.     }
  853.     } else {
  854.     if ((Csegment->flags | sym->flags) & SYM_UNKNOWN) {
  855.         ++Redo;
  856.         Redo_why |= 1 << 8;
  857.     } else {
  858.         register long n = sym->value - (Csegment->org % sym->value);
  859.         if (n != sym->value)
  860.         genfill(fill, n, 1);
  861.     }
  862.     }
  863.     freesymbollist(sym);
  864.     programlabel();
  865. }
  866.  
  867. v_subroutine()
  868. {
  869.     ++Lastlocalindex;
  870.     Localindex = Lastlocalindex;
  871.     programlabel();
  872. }
  873.  
  874. v_equ(str)
  875. char *str;
  876. {
  877.     SYMBOL *sym = eval(str);
  878.     SYMBOL *lab;
  879.  
  880.     lab = findsymbol(Av[0], strlen(Av[0]));
  881.     if (!lab)
  882.     lab = createsymbol(Av[0], strlen(Av[0]));
  883.     if (!(lab->flags & SYM_UNKNOWN)) {
  884.     if (sym->flags & SYM_UNKNOWN) {
  885.         ++Redo;
  886.         Redo_why |= 1 << 9;
  887.     } else {
  888.         if (lab->value != sym->value) {
  889.         asmerr(13,0);
  890.         printf("old value: $%04lx  new value: $%04lx\n", lab->value, sym->value);
  891.         ++Redo;
  892.         Redo_why |= 1 << 10;
  893.         }
  894.     }
  895.     }
  896.     lab->value = sym->value;
  897.     lab->flags = sym->flags & (SYM_UNKNOWN|SYM_STRING);
  898.     lab->string = sym->string;
  899.     sym->flags &= ~(SYM_STRING|SYM_MACRO);
  900.     freesymbollist(sym);
  901. }
  902.  
  903. v_eqm(str)
  904. char *str;
  905. {
  906.     register SYMBOL *lab;
  907.     register int len = strlen(Av[0]);
  908.  
  909.     if (lab = findsymbol(Av[0], len)) {
  910.     if (lab->flags & SYM_STRING)
  911.         free(lab->string);
  912.     } else {
  913.     lab = createsymbol(Av[0], len);
  914.     }
  915.     lab->value = 0;
  916.     lab->flags = SYM_STRING | SYM_SET | SYM_MACRO;
  917.     lab->string = strcpy(malloc(strlen(str)+1), str);
  918. }
  919.  
  920. v_echo(str)
  921. char *str;
  922. {
  923.     SYMBOL *sym = eval(str);
  924.     SYMBOL *s;
  925.     char buf[256];
  926.  
  927.     for (s = sym; s; s = s->next) {
  928.     if (!(s->flags & SYM_UNKNOWN)) {
  929.         if (s->flags & (SYM_MACRO|SYM_STRING))
  930.         sprintf(buf,"%s", s->string);
  931.         else
  932.         sprintf(buf,"$%lx", s->value);
  933.         if (FI_listfile)
  934.         fprintf(FI_listfile, " %s", buf);
  935.         printf(" %s", buf);
  936.     }
  937.     }
  938.     puts("");
  939.     if (FI_listfile)
  940.     putc('\n', FI_listfile);
  941. }
  942.  
  943. v_set(str)
  944. char *str;
  945. {
  946.     SYMBOL *sym = eval(str);
  947.     SYMBOL *lab;
  948.  
  949.     lab = findsymbol(Av[0], strlen(Av[0]));
  950.     if (!lab)
  951.     lab = createsymbol(Av[0], strlen(Av[0]));
  952.     lab->value = sym->value;
  953.     lab->flags = sym->flags & (SYM_UNKNOWN|SYM_STRING);
  954.     lab->string = sym->string;
  955.     sym->flags &= ~(SYM_STRING|SYM_MACRO);
  956.     freesymbollist(sym);
  957. }
  958.  
  959. v_execmac(str,mac)
  960. char *str;
  961. MACRO *mac;
  962. {
  963.     register INCFILE *inc;
  964.     STRLIST *base;
  965.     register STRLIST **psl, *sl;
  966.     register char *s1, *s2;
  967.  
  968.     programlabel();
  969.  
  970.     if (Mlevel == MAXMACLEVEL) {
  971.     puts("infinite macro recursion");
  972.     return(0);
  973.     }
  974.     ++Mlevel;
  975.     base = (STRLIST *)malloc(strlen(str)+5);
  976.     base->next = NULL;
  977.     strcpy(base->buf, str);
  978.     psl = &base->next;
  979.     while (*str && *str != '\n') {
  980.     s1 = str;
  981.     while (*str && *str != '\n' && *str != ',')
  982.         ++str;
  983.     sl = (STRLIST *)malloc(5+(str-s1));
  984.     sl->next = NULL;
  985.     *psl = sl;
  986.     psl = &sl->next;
  987.     bmov(s1, sl->buf, (str-s1));
  988.     sl->buf[str-s1] = 0;
  989.     if (*str == ',')
  990.         ++str;
  991.     while (*str == ' ')
  992.         ++str;
  993.     }
  994.  
  995.     inc = (INCFILE *)zmalloc(sizeof(INCFILE));
  996.     inc->next = Incfile;
  997.     inc->name = mac->name;
  998.     inc->fi   = Incfile->fi;    /* garbage */
  999.     inc->lineno = 0;
  1000.     inc->flags = INF_MACRO;
  1001.     inc->saveidx = Localindex;
  1002.     inc->strlist = mac->strlist;
  1003.     inc->args     = base;
  1004.     Incfile = inc;
  1005.  
  1006.     ++Lastlocalindex;
  1007.     Localindex = Lastlocalindex;
  1008. }
  1009.  
  1010. void
  1011. v_end()
  1012. {
  1013.     puts("END not implemented yet");
  1014. }
  1015.  
  1016. void
  1017. v_endm()
  1018. {
  1019.     register INCFILE *inc = Incfile;
  1020.     register STRLIST *args, *an;
  1021.  
  1022.     programlabel();
  1023.     if (inc->flags & INF_MACRO) {
  1024.     --Mlevel;
  1025.     for (args = inc->args; args; args = an) {
  1026.         an = args->next;
  1027.         free(args);
  1028.     }
  1029.     Localindex = inc->saveidx;
  1030.     Incfile = inc->next;
  1031.     free(inc);
  1032.     return;
  1033.     }
  1034.     puts("not within a macro");
  1035. }
  1036.  
  1037. v_mexit()
  1038. {
  1039.     v_endm();
  1040. }
  1041.  
  1042. v_ifconst(str)
  1043. char *str;
  1044. {
  1045.     SYMBOL *sym;
  1046.  
  1047.     programlabel();
  1048.     sym = eval(str);
  1049.     pushif(sym->flags == 0);
  1050.     freesymbollist(sym);
  1051. }
  1052.  
  1053. v_ifnconst(str)
  1054. char *str;
  1055. {
  1056.     SYMBOL *sym;
  1057.  
  1058.     programlabel();
  1059.     sym = eval(str);
  1060.     pushif(sym->flags != 0);
  1061.     freesymbollist(sym);
  1062. }
  1063.  
  1064. void
  1065. v_if(str)
  1066. char *str;
  1067. {
  1068.     SYMBOL *sym;
  1069.  
  1070.     if (!Ifstack->true || !Ifstack->acctrue) {
  1071.     pushif(0);
  1072.     return;
  1073.     }
  1074.     programlabel();
  1075.     sym = eval(str);
  1076.     if (sym->flags) {
  1077.     ++Redo;
  1078.     Redo_why |= 1 << 11;
  1079.     pushif(0);
  1080.     Ifstack->acctrue = 0;
  1081.     } else {
  1082.     pushif((short)!!sym->value);
  1083.     }
  1084.     freesymbollist(sym);
  1085. }
  1086.  
  1087. v_else()
  1088. {
  1089.     if (Ifstack->acctrue && !(Ifstack->flags & IFF_BASE)) {
  1090.     programlabel();
  1091.     Ifstack->true = !Ifstack->true;
  1092.     }
  1093. }
  1094.  
  1095. v_endif()
  1096. {
  1097.     IFSTACK *ifs = Ifstack;
  1098.  
  1099.     if (!(ifs->flags & IFF_BASE)) {
  1100.     if (ifs->acctrue)
  1101.         programlabel();
  1102.     if (ifs->file != Incfile) {
  1103.         puts("too many endif's");
  1104.     } else {
  1105.         Ifstack = ifs->next;
  1106.         free(ifs);
  1107.     }
  1108.     }
  1109. }
  1110.  
  1111. v_repeat(str)
  1112. char *str;
  1113. {
  1114.     register REPLOOP *rp;
  1115.     register SYMBOL *sym;
  1116.  
  1117.     if (!Ifstack->true || !Ifstack->acctrue) {
  1118.     pushif(0);
  1119.     return;
  1120.     }
  1121.     programlabel();
  1122.     sym = eval(str);
  1123.     if (sym->value == 0) {
  1124.     pushif(0);
  1125.     freesymbollist(sym);
  1126.     return;
  1127.     }
  1128.     rp = (REPLOOP *)zmalloc(sizeof(REPLOOP));
  1129.     rp->next = Reploop;
  1130.     rp->file = Incfile;
  1131.     if (Incfile->flags & INF_MACRO)
  1132.     rp->seek = (long)Incfile->strlist;
  1133.     else
  1134.     rp->seek = ftell(Incfile->fi);
  1135.     rp->lineno = Incfile->lineno;
  1136.     rp->count = sym->value;
  1137.     if (rp->flags = sym->flags) {
  1138.     ++Redo;
  1139.     Redo_why |= 1 << 12;
  1140.     }
  1141.     Reploop = rp;
  1142.     freesymbollist(sym);
  1143.     pushif(1);
  1144. }
  1145.  
  1146. void
  1147. v_repend()
  1148. {
  1149.     if (!Ifstack->true || !Ifstack->acctrue) {
  1150.     v_endif();
  1151.     return;
  1152.     }
  1153.     if (Reploop && Reploop->file == Incfile) {
  1154.     if (Reploop->flags == 0 && --Reploop->count) {
  1155.         if (Incfile->flags & INF_MACRO)
  1156.         Incfile->strlist = (STRLIST *)Reploop->seek;
  1157.         else
  1158.         fseek(Incfile->fi,Reploop->seek,0);
  1159.         Incfile->lineno = Reploop->lineno;
  1160.     } else {
  1161.         rmnode(&Reploop, sizeof(REPLOOP));
  1162.         v_endif();
  1163.     }
  1164.     return;
  1165.     }
  1166.     puts("no repeat");
  1167. }
  1168.  
  1169. static long Seglen;
  1170. static long Seekback;
  1171.  
  1172. void
  1173. generate()
  1174. {
  1175.     long seekpos;
  1176.     static ulong org;
  1177.     short i;
  1178.  
  1179.     if (!Redo) {
  1180.     if (!(Csegment->flags & SF_BSS)) {
  1181.         for (i = Glen - 1; i >= 0; --i)
  1182.         CheckSum += Gen[i];
  1183.         if (Fisclear) {
  1184.         Fisclear = 0;
  1185.         if (Csegment->flags & SF_UNKNOWN) {
  1186.             ++Redo;
  1187.             Redo_why |= 1 << 1;
  1188.             return;
  1189.         }
  1190.         org = Csegment->org;
  1191.         if (F_format < 3) {
  1192.             putc((short)(org & 0xFF), FI_temp);
  1193.             putc((short)((org >> 8) & 0xFF), FI_temp);
  1194.             if (F_format == 2) {
  1195.             Seekback = ftell(FI_temp);
  1196.             Seglen = 0;
  1197.             putc(0, FI_temp);
  1198.             putc(0, FI_temp);
  1199.             }
  1200.         }
  1201.         }
  1202.         switch(F_format) {
  1203.         default:
  1204.         case 3:
  1205.         case 1:
  1206.         if (Csegment->org < org) {
  1207.             printf("segment: %s %s  vs current org: %04lx\n", Csegment->name, sftos(Csegment->org, Csegment->flags), org);
  1208.             asmerr(12, 1);
  1209.             exit(1);
  1210.         }
  1211.         while (Csegment->org != org) {
  1212.             putc(OrgFill, FI_temp);
  1213.             ++org;
  1214.         }
  1215.         fwrite(Gen, Glen, 1, FI_temp);
  1216.         break;
  1217.         case 2:
  1218.         if (org != Csegment->org) {
  1219.             org = Csegment->org;
  1220.             seekpos = ftell(FI_temp);
  1221.             fseek(FI_temp, Seekback, 0);
  1222.             putc((short)(Seglen & 0xFF), FI_temp);
  1223.             putc((short)((Seglen >> 8) & 0xFF), FI_temp);
  1224.             fseek(FI_temp, seekpos, 0);
  1225.             putc((short)(org & 0xFF), FI_temp);
  1226.             putc((short)((org >> 8) & 0xFF), FI_temp);
  1227.             Seekback = ftell(FI_temp);
  1228.             Seglen = 0;
  1229.             putc(0, FI_temp);
  1230.             putc(0, FI_temp);
  1231.         }
  1232.         fwrite(Gen, Glen, 1, FI_temp);
  1233.         Seglen += Glen;
  1234.         }
  1235.         org += Glen;
  1236.     }
  1237.     }
  1238.     Csegment->org += Glen;
  1239.     if (Csegment->flags & SF_RORG)
  1240.     Csegment->rorg += Glen;
  1241. }
  1242.  
  1243. void
  1244. closegenerate()
  1245. {
  1246.     if (!Redo) {
  1247.     if (F_format == 2) {
  1248.         fseek(FI_temp, Seekback, 0);
  1249.         putc((short)(Seglen & 0xFF), FI_temp);
  1250.         putc((short)((Seglen >> 8) & 0xFF), FI_temp);
  1251.         fseek(FI_temp, 0L, 2);
  1252.     }
  1253.     }
  1254. }
  1255.  
  1256. void
  1257. genfill(fill, entries, size)
  1258. long fill, entries;
  1259. {
  1260.     register long bytes = entries;  /*    multiplied later    */
  1261.     register short i;
  1262.     register ubyte c3,c2,c1,c0;
  1263.  
  1264.     if (!bytes)
  1265.     return;
  1266.     c3 = fill >> 24;
  1267.     c2 = fill >> 16;
  1268.     c1 = fill >> 8;
  1269.     c0 = fill;
  1270.     switch(size) {
  1271.     case 1:
  1272.     bset(Gen, sizeof(Gen), c0);
  1273.     break;
  1274.     case 2:
  1275.     bytes <<= 1;
  1276.     for (i = 0; i < sizeof(Gen); i += 2) {
  1277.         if (MsbOrder) {
  1278.         Gen[i+0] = c1;
  1279.         Gen[i+1] = c0;
  1280.         } else {
  1281.         Gen[i+0] = c0;
  1282.         Gen[i+1] = c1;
  1283.         }
  1284.     }
  1285.     break;
  1286.     case 4:
  1287.     bytes <<= 2;
  1288.     for (i = 0; i < sizeof(Gen); i += 4) {
  1289.         if (MsbOrder) {
  1290.         Gen[i+0] = c3;
  1291.         Gen[i+1] = c2;
  1292.         Gen[i+2] = c1;
  1293.         Gen[i+3] = c0;
  1294.         } else {
  1295.         Gen[i+0] = c0;
  1296.         Gen[i+1] = c1;
  1297.         Gen[i+2] = c2;
  1298.         Gen[i+3] = c3;
  1299.         }     
  1300.     }
  1301.     break;
  1302.     }
  1303.     for (Glen = sizeof(Gen); bytes > sizeof(Gen); bytes -= sizeof(Gen))
  1304.     generate();
  1305.     Glen = bytes;
  1306.     generate();
  1307. }
  1308.  
  1309. void
  1310. pushif(bool)
  1311. {
  1312.     register IFSTACK *ifs = (IFSTACK *)zmalloc(sizeof(IFSTACK));
  1313.     ifs->next = Ifstack;
  1314.     ifs->file = Incfile;
  1315.     ifs->flags = 0;
  1316.     ifs->true  = bool;
  1317.     ifs->acctrue = Ifstack->acctrue && Ifstack->true;
  1318.     Ifstack = ifs;
  1319. }
  1320.  
  1321. \Rogue\Monster\
  1322. else
  1323.   echo "will not over write src/ops.c"
  1324. fi
  1325. if [ `wc -c src/ops.c | awk '{printf $1}'` -ne 20291 ]
  1326. then
  1327. echo `wc -c src/ops.c | awk '{print "Got " $1 ", Expected " 20291}'`
  1328. fi
  1329. if `test ! -s src/mne6502.c`
  1330. then
  1331. echo "writing src/mne6502.c"
  1332. cat > src/mne6502.c << '\Rogue\Monster\'
  1333.  
  1334. /*
  1335.  *  MNE6502.C
  1336.  *
  1337.  *  (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  1338.  *
  1339.  */
  1340.  
  1341. #include "asm.h"
  1342.  
  1343. extern void v_mnemonic();
  1344.  
  1345. #define ASTD    AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX|\
  1346.         AF_WORDADRY|AF_INDBYTEX|AF_INDBYTEY
  1347.  
  1348. MNE Mne6502[] = {
  1349.     NULL, v_mnemonic, "adc", 0, AF_IMM8|ASTD,
  1350.     { 0x69, 0x65, 0x75, 0x6D, 0x7D, 0x79, 0x61, 0x71 },
  1351.     NULL, v_mnemonic, "and", 0, AF_IMM8|ASTD,
  1352.     { 0x29, 0x25, 0x35, 0x2D, 0x3D, 0x39, 0x21, 0x31 },
  1353.     NULL, v_mnemonic, "asl", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX,
  1354.     { 0x0A, 0x06, 0x16, 0x0E, 0x1E },
  1355.     NULL, v_mnemonic, "bcc", 0, AF_REL, { 0x90 },
  1356.     NULL, v_mnemonic, "bcs", 0, AF_REL, { 0xB0 },
  1357.     NULL, v_mnemonic, "beq", 0, AF_REL, { 0xF0 },
  1358.     NULL, v_mnemonic, "bit", 0, AF_BYTEADR|AF_WORDADR,
  1359.     { 0x24, 0x2C },
  1360.     NULL, v_mnemonic, "bmi", 0, AF_REL, { 0x30 },
  1361.     NULL, v_mnemonic, "bne", 0, AF_REL, { 0xD0 },
  1362.     NULL, v_mnemonic, "bpl", 0, AF_REL, { 0x10 },
  1363.     NULL, v_mnemonic, "brk", 0, AF_IMP, { 0x00 },
  1364.     NULL, v_mnemonic, "bvc", 0, AF_REL, { 0x50 },
  1365.     NULL, v_mnemonic, "bvs", 0, AF_REL, { 0x70 },
  1366.     NULL, v_mnemonic, "clc", 0, AF_IMP, { 0x18 },
  1367.     NULL, v_mnemonic, "cld", 0, AF_IMP, { 0xD8 },
  1368.     NULL, v_mnemonic, "cli", 0, AF_IMP, { 0x58 },
  1369.     NULL, v_mnemonic, "clv", 0, AF_IMP, { 0xB8 },
  1370.     NULL, v_mnemonic, "cmp", 0, AF_IMM8|ASTD,
  1371.     { 0xC9, 0xC5, 0xD5, 0xCD, 0xDD, 0xD9, 0xC1, 0xD1 },
  1372.     NULL, v_mnemonic, "cpx", 0, AF_IMM8|AF_BYTEADR|AF_WORDADR,
  1373.     { 0xE0, 0xE4, 0xEC },
  1374.     NULL, v_mnemonic, "cpy", 0, AF_IMM8|AF_BYTEADR|AF_WORDADR,
  1375.     { 0xC0, 0xC4, 0xCC },
  1376.     NULL, v_mnemonic, "dec", 0, AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX,
  1377.     { 0xC6, 0xD6, 0xCE, 0xDE },
  1378.     NULL, v_mnemonic, "dex", 0, AF_IMP, { 0xCA },
  1379.     NULL, v_mnemonic, "dey", 0, AF_IMP, { 0x88 },
  1380.     NULL, v_mnemonic, "eor", 0, AF_IMM8|ASTD,
  1381.     { 0x49, 0x45, 0x55, 0x4D, 0x5D, 0x59, 0x41,0x51 },
  1382.     NULL, v_mnemonic, "inc", 0, AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX,
  1383.     { 0xE6, 0xF6, 0xEE, 0xFE },
  1384.     NULL, v_mnemonic, "inx", 0, AF_IMP, { 0xE8 },
  1385.     NULL, v_mnemonic, "iny", 0, AF_IMP, { 0xC8 },
  1386.     NULL, v_mnemonic, "jmp", 0, AF_WORDADR|AF_INDWORD,
  1387.     { 0x4C, 0x6C },
  1388.     NULL, v_mnemonic, "jsr", 0, AF_WORDADR, { 0x20 },
  1389.     NULL, v_mnemonic, "lda", 0, AF_IMM8|ASTD,
  1390.     { 0xA9, 0xA5, 0xB5, 0xAD, 0xBD, 0xB9, 0xA1, 0xB1 },
  1391.     NULL, v_mnemonic, "ldx", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRY|AF_WORDADR|AF_WORDADRY,
  1392.     { 0xA2, 0xA6, 0xB6, 0xAE, 0xBE },
  1393.     NULL, v_mnemonic, "ldy", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX,
  1394.     { 0xA0, 0xA4, 0xB4, 0xAC, 0xBC },
  1395.     NULL, v_mnemonic, "lsr", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX,
  1396.     { 0x4A, 0x46, 0x56, 0x4E, 0x5E },
  1397.     NULL, v_mnemonic, "nop", 0, AF_IMP, { 0xEA },
  1398.     NULL, v_mnemonic, "ora", 0, AF_IMM8|ASTD,
  1399.     { 0x09, 0x05, 0x15, 0x0D, 0x1D, 0x19, 0x01, 0x11 },
  1400.     NULL, v_mnemonic, "pha", 0, AF_IMP, { 0x48 },
  1401.     NULL, v_mnemonic, "php", 0, AF_IMP, { 0x08 },
  1402.     NULL, v_mnemonic, "pla", 0, AF_IMP, { 0x68 },
  1403.     NULL, v_mnemonic, "plp", 0, AF_IMP, { 0x28 },
  1404.     NULL, v_mnemonic, "rol", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX,
  1405.     { 0x2A, 0x26, 0x36, 0x2E, 0x3E },
  1406.     NULL, v_mnemonic, "ror", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX,
  1407.     { 0x6A, 0x66, 0x76, 0x6E, 0x7E },
  1408.     NULL, v_mnemonic, "rti", 0, AF_IMP, { 0x40 },
  1409.     NULL, v_mnemonic, "rts", 0, AF_IMP, { 0x60 },
  1410.     NULL, v_mnemonic, "sbc", 0, AF_IMM8|ASTD,
  1411.     { 0xE9, 0xE5, 0xF5, 0xED, 0xFD, 0xF9, 0xE1, 0xF1 },
  1412.     NULL, v_mnemonic, "sec", 0, AF_IMP, { 0x38 },
  1413.     NULL, v_mnemonic, "sed", 0, AF_IMP, { 0xF8 },
  1414.     NULL, v_mnemonic, "sei", 0, AF_IMP, { 0x78 },
  1415.     NULL, v_mnemonic, "sta", 0, ASTD,
  1416.     { 0x85, 0x95, 0x8D, 0x9D, 0x99, 0x81, 0x91 },
  1417.     NULL, v_mnemonic, "stx", 0, AF_BYTEADR|AF_BYTEADRY|AF_WORDADR,
  1418.     { 0x86, 0x96, 0x8E },
  1419.     NULL, v_mnemonic, "sty", 0, AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1420.     { 0x84, 0x94, 0x8C },
  1421.     NULL, v_mnemonic, "tax", 0, AF_IMP, { 0xAA },
  1422.     NULL, v_mnemonic, "tay", 0, AF_IMP, { 0xA8 },
  1423.     NULL, v_mnemonic, "tsx", 0, AF_IMP, { 0xBA },
  1424.     NULL, v_mnemonic, "txa", 0, AF_IMP, { 0x8A },
  1425.     NULL, v_mnemonic, "txs", 0, AF_IMP, { 0x9A },
  1426.     NULL, v_mnemonic, "tya", 0, AF_IMP, { 0x98 },
  1427.     NULL
  1428. };
  1429.  
  1430.  
  1431.  
  1432. \Rogue\Monster\
  1433. else
  1434.   echo "will not over write src/mne6502.c"
  1435. fi
  1436. if [ `wc -c src/mne6502.c | awk '{printf $1}'` -ne 4254 ]
  1437. then
  1438. echo `wc -c src/mne6502.c | awk '{print "Got " $1 ", Expected " 4254}'`
  1439. fi
  1440. if `test ! -s src/mne6811.c`
  1441. then
  1442. echo "writing src/mne6811.c"
  1443. cat > src/mne6811.c << '\Rogue\Monster\'
  1444.  
  1445. /*
  1446.  *  MNE6811.C
  1447.  *
  1448.  *  (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  1449.  *
  1450.  *  68HC11 processor
  1451.  *
  1452.  *  addressing modes:
  1453.  *    AF_IMM8
  1454.  *    AF_IMM16
  1455.  *    AF_BYTEADR
  1456.  *    AF_WORDADR
  1457.  *    AF_BYTEADRX
  1458.  *    AF_BYTEADRY
  1459.  *    AF_IMP
  1460.  *    AF_REL
  1461.  *
  1462.  *  flags:
  1463.  *    MF_MASK     contains additional byte argument
  1464.  *    MF_REL        contains additional relative argument
  1465.  */
  1466.  
  1467. #include "asm.h"
  1468.  
  1469. extern void v_mnemonic();
  1470.  
  1471. #define AF_STD     (AF_BYTEADR|AF_BYTEADRX|AF_BYTEADRY|AF_WORDADR)
  1472. #define AF_STDI  (AF_IMM8|AF_STD)
  1473. #define AF_STDD  (AF_IMM16|AF_STD)
  1474. #define AF_ASL     (AF_BYTEADRX|AF_BYTEADRY|AF_WORDADR)
  1475. #define AF_BCLR  (AF_BYTEADR|AF_BYTEADRX|AF_BYTEADRY)
  1476.  
  1477. MNE Mne68HC11[] = {
  1478.     NULL, v_mnemonic, "aba",    0, AF_IMP, { 0x1B },
  1479.     NULL, v_mnemonic, "abx",    0, AF_IMP, { 0x3A },
  1480.     NULL, v_mnemonic, "aby",    0, AF_IMP, { 0x183A },
  1481.     NULL, v_mnemonic, "adca",   0, AF_STDI,{ 0x89, 0x99, 0xA9, 0x18A9, 0xB9 },
  1482.     NULL, v_mnemonic, "adcb",   0, AF_STDI,{ 0xC9, 0xD9, 0xE9, 0x18E9, 0xF9 },
  1483.     NULL, v_mnemonic, "adda",   0, AF_STDI,{ 0x8B, 0x9B, 0xAB, 0x18AB, 0xBB },
  1484.     NULL, v_mnemonic, "addb",   0, AF_STDI,{ 0xCB, 0xDB, 0xEB, 0x18EB, 0xFB },
  1485.     NULL, v_mnemonic, "addd",   0, AF_STDD,{ 0xC3, 0xD3, 0xE3, 0x18E3, 0xF3 },
  1486.     NULL, v_mnemonic, "anda",   0, AF_STDI,{ 0x84, 0x94, 0xA4, 0x18A4, 0xB4 },
  1487.     NULL, v_mnemonic, "andb",   0, AF_STDI,{ 0xC4, 0xD4, 0xE4, 0x18E4, 0xF4 },
  1488.     NULL, v_mnemonic, "asla",   0, AF_IMP, { 0x48 },
  1489.     NULL, v_mnemonic, "aslb",   0, AF_IMP, { 0x58 },
  1490.     NULL, v_mnemonic, "asl",    0, AF_ASL, { 0x68, 0x1868, 0x78 },
  1491.     NULL, v_mnemonic, "asld",   0, AF_IMP, { 0x05 },
  1492.     NULL, v_mnemonic, "asra",   0, AF_IMP, { 0x47 },
  1493.     NULL, v_mnemonic, "asrb",   0, AF_IMP, { 0x57 },
  1494.     NULL, v_mnemonic, "asr",    0, AF_ASL, { 0x67, 0x1867, 0x77 },
  1495.     /*    no asrd */
  1496.     NULL, v_mnemonic, "bcc",    0, AF_REL, { 0x24 },
  1497.     NULL, v_mnemonic, "bclr",   MF_MASK, AF_BCLR, { 0x15, 0x1D, 0x181D },
  1498.     NULL, v_mnemonic, "bcs",    0, AF_REL, { 0x25 },
  1499.     NULL, v_mnemonic, "beq",    0, AF_REL, { 0x27 },
  1500.     NULL, v_mnemonic, "bge",    0, AF_REL, { 0x2C },
  1501.     NULL, v_mnemonic, "bgt",    0, AF_REL, { 0x2E },
  1502.     NULL, v_mnemonic, "bhi",    0, AF_REL, { 0x22 },
  1503.     NULL, v_mnemonic, "bhs",    0, AF_REL, { 0x24 },
  1504.     NULL, v_mnemonic, "bita",   0, AF_STDI,{ 0x85, 0x95, 0xA5, 0x18A5, 0xB5 },
  1505.     NULL, v_mnemonic, "bitb",   0, AF_STDI,{ 0xC5, 0xD5, 0xE5, 0x18E5, 0xF5 },
  1506.     NULL, v_mnemonic, "ble",    0, AF_REL, { 0x2F },
  1507.     NULL, v_mnemonic, "blo",    0, AF_REL, { 0x25 },
  1508.     NULL, v_mnemonic, "bls",    0, AF_REL, { 0x23 },
  1509.     NULL, v_mnemonic, "blt",    0, AF_REL, { 0x2D },
  1510.     NULL, v_mnemonic, "bmi",    0, AF_REL, { 0x2B },
  1511.     NULL, v_mnemonic, "bne",    0, AF_REL, { 0x26 },
  1512.     NULL, v_mnemonic, "bpl",    0, AF_REL, { 0x2A },
  1513.     NULL, v_mnemonic, "bra",    0, AF_REL, { 0x20 },
  1514.     NULL, v_mnemonic, "brclr",  MF_MASK|MF_REL, AF_BCLR,{ 0x13, 0x1F, 0x181F },
  1515.     NULL, v_mnemonic, "brn",    0, AF_REL, { 0x21 },
  1516.     NULL, v_mnemonic, "brset",  MF_MASK|MF_REL, AF_BCLR,{ 0x12, 0x1E, 0x181E },
  1517.     NULL, v_mnemonic, "bset",   MF_MASK, AF_BCLR, { 0x14, 0x1C, 0x181C },
  1518.     NULL, v_mnemonic, "bsr",    0, AF_REL, { 0x8D },
  1519.     NULL, v_mnemonic, "bvc",    0, AF_REL, { 0x28 },
  1520.     NULL, v_mnemonic, "bvs",    0, AF_REL, { 0x29 },
  1521.     NULL, v_mnemonic, "cba",    0, AF_IMP, { 0x11 },
  1522.     NULL, v_mnemonic, "clc",    0, AF_IMP, { 0x0C },
  1523.     NULL, v_mnemonic, "cli",    0, AF_IMP, { 0x0E },
  1524.     NULL, v_mnemonic, "clra",   0, AF_IMP, { 0x4F },
  1525.     NULL, v_mnemonic, "clrb",   0, AF_IMP, { 0x5F },
  1526.     NULL, v_mnemonic, "clr",    0, AF_ASL, { 0x6F, 0x186F, 0x7F },
  1527.     NULL, v_mnemonic, "clv",    0, AF_IMP, { 0x0A },
  1528.     NULL, v_mnemonic, "cmpa",   0, AF_STDI,{ 0x81, 0x91, 0xA1, 0x18A1, 0xB1 },
  1529.     NULL, v_mnemonic, "cmpb",   0, AF_STDI,{ 0xC1, 0xD1, 0xE1, 0x18E1, 0xF1 },
  1530.     NULL, v_mnemonic, "coma",   0, AF_IMP, { 0x43 },
  1531.     NULL, v_mnemonic, "comb",   0, AF_IMP, { 0x53 },
  1532.     NULL, v_mnemonic, "com",    0, AF_ASL, { 0x63, 0x1863, 0x73 },
  1533.     NULL, v_mnemonic, "cpd",    0, AF_STDD,{ 0x1A83, 0x1A93, 0x1AA3, 0xCDA3, 0x1AB3 },
  1534.     NULL, v_mnemonic, "cpx",    0, AF_STDD,{ 0x8C, 0x9C, 0xAC, 0xCDAC, 0xBC },
  1535.     NULL, v_mnemonic, "cpy",    0, AF_STDD,{ 0x188C, 0x189C, 0x1AAC, 0x18AC, 0x18BC },
  1536.     NULL, v_mnemonic, "daa",    0, AF_IMP, { 0x19 },
  1537.     NULL, v_mnemonic, "deca",   0, AF_IMP, { 0x4A },
  1538.     NULL, v_mnemonic, "decb",   0, AF_IMP, { 0x5A },
  1539.     NULL, v_mnemonic, "dec",    0, AF_ASL, { 0x6A, 0x186A, 0x7A },
  1540.     NULL, v_mnemonic, "des",    0, AF_IMP, { 0x34 },
  1541.     NULL, v_mnemonic, "dex",    0, AF_IMP, { 0x09 },
  1542.     NULL, v_mnemonic, "dey",    0, AF_IMP, { 0x1809 },
  1543.     NULL, v_mnemonic, "eora",   0, AF_STDI,{ 0x88, 0x98, 0xA8, 0x18A8, 0xB8 },
  1544.     NULL, v_mnemonic, "eorb",   0, AF_STDI,{ 0xC8, 0xD8, 0xE8, 0x18E8, 0xF8 },
  1545.     NULL, v_mnemonic, "fdiv",   0, AF_IMP, { 0x03 },
  1546.     NULL, v_mnemonic, "idiv",   0, AF_IMP, { 0x02 },
  1547.     NULL, v_mnemonic, "inca",   0, AF_IMP, { 0x4C },
  1548.     NULL, v_mnemonic, "incb",   0, AF_IMP, { 0x5C },
  1549.     NULL, v_mnemonic, "inc",    0, AF_ASL, { 0x6C, 0x186C, 0x7C },
  1550.     NULL, v_mnemonic, "ins",    0, AF_IMP, { 0x31 },
  1551.     NULL, v_mnemonic, "inx",    0, AF_IMP, { 0x08 },
  1552.     NULL, v_mnemonic, "iny",    0, AF_IMP, { 0x1808 },
  1553.     NULL, v_mnemonic, "jmp",    0, AF_ASL, { 0x6E, 0x186E, 0x7E },
  1554.     NULL, v_mnemonic, "jsr",    0, AF_STD, { 0x9D, 0xAD, 0x18AD, 0xBD },
  1555.     NULL, v_mnemonic, "ldaa",   0, AF_STDI,{ 0x86, 0x96, 0xA6, 0x18A6, 0xB6 },
  1556.     NULL, v_mnemonic, "ldab",   0, AF_STDI,{ 0xC6, 0xD6, 0xE6, 0x18E6, 0xF6 },
  1557.     NULL, v_mnemonic, "ldd",    0, AF_STDD,{ 0xCC, 0xDC, 0xEC, 0x18EC, 0xFC },
  1558.     NULL, v_mnemonic, "lds",    0, AF_STDD,{ 0x8E, 0x9E, 0xAE, 0x18AE, 0xBE },
  1559.     NULL, v_mnemonic, "ldx",    0, AF_STDD,{ 0xCE, 0xDE, 0xEE, 0xCDEE, 0xFE },
  1560.     NULL, v_mnemonic, "ldy",    0, AF_STDD,{ 0x18CE, 0x18DE, 0x1AEE, 0x18EE, 0x18FE },
  1561.     NULL, v_mnemonic, "lsla",   0, AF_IMP, { 0x48 },
  1562.     NULL, v_mnemonic, "lslb",   0, AF_IMP, { 0x58 },
  1563.     NULL, v_mnemonic, "lsl",    0, AF_ASL, { 0x68, 0x1868, 0x78 },
  1564.     NULL, v_mnemonic, "lsld",   0, AF_IMP, { 0x05 },
  1565.     NULL, v_mnemonic, "lsra",   0, AF_IMP, { 0x44 },
  1566.     NULL, v_mnemonic, "lsrb",   0, AF_IMP, { 0x54 },
  1567.     NULL, v_mnemonic, "lsr",    0, AF_ASL, { 0x64, 0x1864, 0x74 },
  1568.     NULL, v_mnemonic, "lsrd",   0, AF_IMP, { 0x04 },
  1569.     NULL, v_mnemonic, "mul",    0, AF_IMP, { 0x3D },
  1570.     NULL, v_mnemonic, "nega",   0, AF_IMP, { 0x40 },
  1571.     NULL, v_mnemonic, "negb",   0, AF_IMP, { 0x50 },
  1572.     NULL, v_mnemonic, "neg",    0, AF_ASL, { 0x60, 0x1860, 0x70 },
  1573.     NULL, v_mnemonic, "nop",    0, AF_IMP, { 0x01 },
  1574.     NULL, v_mnemonic, "oraa",   0, AF_STDI,{ 0x8A, 0x9A, 0xAA, 0x18AA, 0xBA },
  1575.     NULL, v_mnemonic, "orab",   0, AF_STDI,{ 0xCA, 0xDA, 0xEA, 0x18EA, 0xFA },
  1576.     NULL, v_mnemonic, "psha",   0, AF_IMP, { 0x36 },
  1577.     NULL, v_mnemonic, "pshb",   0, AF_IMP, { 0x37 },
  1578.     NULL, v_mnemonic, "pshx",   0, AF_IMP, { 0x3C },
  1579.     NULL, v_mnemonic, "pshy",   0, AF_IMP, { 0x183C },
  1580.     NULL, v_mnemonic, "pula",   0, AF_IMP, { 0x32 },
  1581.     NULL, v_mnemonic, "pulb",   0, AF_IMP, { 0x33 },
  1582.     NULL, v_mnemonic, "pulx",   0, AF_IMP, { 0x38 },
  1583.     NULL, v_mnemonic, "puly",   0, AF_IMP, { 0x1838 },
  1584.     NULL, v_mnemonic, "rola",   0, AF_IMP, { 0x49 },
  1585.     NULL, v_mnemonic, "rolb",   0, AF_IMP, { 0x59 },
  1586.     NULL, v_mnemonic, "rol",    0, AF_ASL, { 0x69, 0x1869, 0x79 },
  1587.     NULL, v_mnemonic, "rora",   0, AF_IMP, { 0x46 },
  1588.     NULL, v_mnemonic, "rorb",   0, AF_IMP, { 0x56 },
  1589.     NULL, v_mnemonic, "ror",    0, AF_ASL, { 0x66, 0x1866, 0x76 },
  1590.     NULL, v_mnemonic, "rti",    0, AF_IMP, { 0x3B },
  1591.     NULL, v_mnemonic, "rts",    0, AF_IMP, { 0x39 },
  1592.     NULL, v_mnemonic, "sba",    0, AF_IMP, { 0x10 },
  1593.     NULL, v_mnemonic, "sbca",   0, AF_STDI,{ 0x82, 0x92, 0xA2, 0x18A2, 0xB2 },
  1594.     NULL, v_mnemonic, "sbcb",   0, AF_STDI,{ 0xC2, 0xD2, 0xE2, 0x18E2, 0xF2 },
  1595.     NULL, v_mnemonic, "sec",    0, AF_IMP, { 0x0D },
  1596.     NULL, v_mnemonic, "sei",    0, AF_IMP, { 0x0F },
  1597.     NULL, v_mnemonic, "sev",    0, AF_IMP, { 0x0B },
  1598.     NULL, v_mnemonic, "staa",   0, AF_STD, { 0x97, 0xA7, 0x18A7, 0xB7 },
  1599.     NULL, v_mnemonic, "stab",   0, AF_STD, { 0xD7, 0xE7, 0x18E7, 0xF7 },
  1600.     NULL, v_mnemonic, "std",    0, AF_STD, { 0xDD, 0xED, 0x18ED, 0xFD },
  1601.     NULL, v_mnemonic, "stop",   0, AF_IMP, { 0xCF },
  1602.     NULL, v_mnemonic, "sts",    0, AF_STD, { 0x9F, 0xAF, 0x18AF, 0xBF },
  1603.     NULL, v_mnemonic, "stx",    0, AF_STD, { 0xDF, 0xEF, 0xCDEF, 0xFF },
  1604.     NULL, v_mnemonic, "sty",    0, AF_STD, { 0x18DF, 0x1AEF, 0x18EF, 0x18FF },
  1605.     NULL, v_mnemonic, "suba",   0, AF_STDI,{ 0x80, 0x90, 0xA0, 0x18A0, 0xB0 },
  1606.     NULL, v_mnemonic, "subb",   0, AF_STDI,{ 0xC0, 0xD0, 0xE0, 0x18E0, 0xF0 },
  1607.     NULL, v_mnemonic, "subd",   0, AF_STDD,{ 0x83, 0x93, 0xA3, 0x18A3, 0xB3 },
  1608.     NULL, v_mnemonic, "swi",    0, AF_IMP, { 0x3F },
  1609.     NULL, v_mnemonic, "tab",    0, AF_IMP, { 0x16 },
  1610.     NULL, v_mnemonic, "tap",    0, AF_IMP, { 0x06 },
  1611.     NULL, v_mnemonic, "tba",    0, AF_IMP, { 0x17 },
  1612.     NULL, v_mnemonic, "test",   0, AF_IMP, { 0x00 },
  1613.     NULL, v_mnemonic, "tpa",    0, AF_IMP, { 0x07 },
  1614.     NULL, v_mnemonic, "tsta",   0, AF_IMP, { 0x4D },
  1615.     NULL, v_mnemonic, "tstb",   0, AF_IMP, { 0x5D },
  1616.     NULL, v_mnemonic, "tst",    0, AF_ASL, { 0x6D, 0x186D, 0x7D },
  1617.     NULL, v_mnemonic, "tsx",    0, AF_IMP, { 0x30 },
  1618.     NULL, v_mnemonic, "tsy",    0, AF_IMP, { 0x1830 },
  1619.     NULL, v_mnemonic, "txs",    0, AF_IMP, { 0x35 },
  1620.     NULL, v_mnemonic, "tys",    0, AF_IMP, { 0x1835 },
  1621.     NULL, v_mnemonic, "wai",    0, AF_IMP, { 0x3E },
  1622.     NULL, v_mnemonic, "xgdx",   0, AF_IMP, { 0x8F },
  1623.     NULL, v_mnemonic, "xgdy",   0, AF_IMP, { 0x188F },
  1624.     NULL
  1625. };
  1626.  
  1627.  
  1628.  
  1629. \Rogue\Monster\
  1630. else
  1631.   echo "will not over write src/mne6811.c"
  1632. fi
  1633. if [ `wc -c src/mne6811.c | awk '{printf $1}'` -ne 9593 ]
  1634. then
  1635. echo `wc -c src/mne6811.c | awk '{print "Got " $1 ", Expected " 9593}'`
  1636. fi
  1637. if `test ! -s src/main.c`
  1638. then
  1639. echo "writing src/main.c"
  1640. cat > src/main.c << '\Rogue\Monster\'
  1641.  
  1642. /*
  1643.  *  MAIN.C
  1644.  *
  1645.  *  (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  1646.  *     Freely Distributable (for non-profit) ONLY.  No redistribution
  1647.  *     of any modified text files or redistribution of a subset of the
  1648.  *     source is allowed.  Redistribution of modified binaries IS allowed
  1649.  *     under the above terms.
  1650.  *
  1651.  *  DASM   sourcefile
  1652.  *
  1653.  *  NOTE: must handle mnemonic extensions and expression decode/compare.
  1654.  */
  1655.  
  1656. #include "asm.h"
  1657.  
  1658. #define MAXLINE 256
  1659. #define ISEGNAME    "code"
  1660.  
  1661. extern uword hash1();
  1662. extern MNE   *findmne();
  1663. extern MNE   Ops[];
  1664. extern void  findext();
  1665. extern void  clearsegs(), clearrefs();
  1666. extern SYMBOL *eval();
  1667. extern char *cleanup();
  1668.  
  1669. uword _fmode = 0;    /*  was trying to port to 16 bit IBM-PC lattice C */
  1670.             /*  but failed    */
  1671.  
  1672. ubyte    Disable_me;
  1673. ubyte    StopAtEnd = 0;
  1674. ubyte    *Extstr;
  1675.  
  1676. main(ac, av)
  1677. ubyte *av[];
  1678. {
  1679.     ubyte buf[MAXLINE];
  1680.     uword pass, i;
  1681.     register ubyte *ptr;
  1682.     register MNE *mne;
  1683.     register ulong oldredo = -1;
  1684.     register ulong oldwhy = 0;
  1685.     register ulong oldeval = 0;
  1686.  
  1687.     addhashtable(Ops);
  1688.     pass = 1;
  1689.  
  1690.     if (ac < 2) {
  1691. fail:
  1692.     puts("DASM V2.11, high level Macro Assembler");
  1693.     puts("(C)Copyright 1988 by Matthew Dillon, All Rights Reserved");
  1694.     puts("redistributable for non-profit only");
  1695.     puts("");
  1696.     puts("DASM sourcefile [options]");
  1697.     puts(" -f#      output format");
  1698.     puts(" -oname   output file");
  1699.     puts(" -lname   list file");
  1700.     puts(" -sname   symbol dump");
  1701.     puts(" -v#      verboseness");
  1702.     puts(" -Dname=exp   define label");
  1703.     exit(1);
  1704.     }
  1705.     puts("DASM V2.11, (c)Copyright 1988 Matthew Dillon, All Rights Reserved");
  1706.     puts("Warning: The meaning of <exp & >exp has been reversed in this release");
  1707.     for (i = 2; i < ac; ++i) {
  1708.     if (av[i][0] == '-') {
  1709.         register ubyte *str = av[i]+2;
  1710.         switch(av[i][1]) {
  1711.         case 'd':
  1712.         Xdebug = atoi(str);
  1713.         printf("Xdebug = %ld\n", Xdebug);
  1714.         break;
  1715.         case 'D':
  1716.         while (*str && *str != '=')
  1717.             ++str;
  1718.         if (*str == '=') {
  1719.             *str = 0;
  1720.             ++str;
  1721.         } else {
  1722.             str = (ubyte *)"0";
  1723.         }
  1724.         Av[0] = av[i]+2;
  1725.         v_set(str);
  1726.         break;
  1727.         case 'f':   /*  F_format    */
  1728.         F_format = atoi(str);
  1729.         if (F_format < 1 || F_format > 3)
  1730.             panic("Illegal format specification");
  1731.         break;
  1732.         case 'o':   /*  F_outfile   */
  1733.         F_outfile = (char *)str;
  1734. nofile:
  1735.         if (*str == 0)
  1736.             panic("need file name for specified option");
  1737.         break;
  1738.         case 'l':   /*  F_listfile  */
  1739.         F_listfile = (char *)str;
  1740.         goto nofile;
  1741.         case 's':   /*  F_symfile   */
  1742.         F_symfile = (char *)str;
  1743.         goto nofile;
  1744.         case 'v':   /*  F_verbose   */
  1745.         F_verbose = atoi(str);
  1746.         break;
  1747.         case 't':   /*  F_temppath  */
  1748.         F_temppath = (char *)str;
  1749.         break;
  1750.         default:
  1751.         goto fail;
  1752.         }
  1753.         continue;
  1754.     }
  1755.     goto fail;
  1756.     }
  1757.  
  1758.     /*    INITIAL SEGMENT */
  1759.  
  1760.     {
  1761.     register SEGMENT *seg = (SEGMENT *)permalloc(sizeof(SEGMENT));
  1762.     seg->name = strcpy(permalloc(sizeof(ISEGNAME)), ISEGNAME);
  1763.     seg->flags= seg->rflags = seg->initflags = seg->initrflags = SF_UNKNOWN;
  1764.     Csegment = Seglist = seg;
  1765.     }
  1766.     /*    TOP LEVEL IF    */
  1767.     {
  1768.     register IFSTACK *ifs = (IFSTACK *)zmalloc(sizeof(IFSTACK));
  1769.     ifs->file = NULL;
  1770.     ifs->flags = IFF_BASE;
  1771.     ifs->acctrue = 1;
  1772.     ifs->true  = 1;
  1773.     Ifstack = ifs;
  1774.     }
  1775. nextpass:
  1776.     Localindex = Lastlocalindex = 0;
  1777.     _fmode = 0x8000;
  1778.     FI_temp = fopen(F_outfile, "w");
  1779.     _fmode = 0;
  1780.     Fisclear = 1;
  1781.     CheckSum = 0;
  1782.     if (FI_temp == NULL) {
  1783.     printf("unable to [re]open '%s'\n", F_outfile);
  1784.     exit(1);
  1785.     }
  1786.     if (F_listfile) {
  1787.     FI_listfile = fopen(F_listfile, "w");
  1788.     if (FI_listfile == NULL) {
  1789.         printf("unable to [re]open '%s'\n", F_listfile);
  1790.         exit(1);
  1791.     }
  1792.     }
  1793.     pushinclude(av[1]);
  1794.     while (Incfile) {
  1795.     for (;;) {
  1796.         char *comment;
  1797.         if (Incfile->flags & INF_MACRO) {
  1798.         if (Incfile->strlist == NULL) {
  1799.             Av[0] = (ubyte *)"";
  1800.             v_mexit();
  1801.             continue;
  1802.         }
  1803.         strcpy(buf, Incfile->strlist->buf);
  1804.         Incfile->strlist = Incfile->strlist->next;
  1805.         } else {
  1806.         if (fgets(buf, MAXLINE, Incfile->fi) == NULL)
  1807.             break;
  1808.         }
  1809.         if (Xdebug)
  1810.         printf("%08lx %s\n", Incfile, buf);
  1811.         comment = cleanup(buf);
  1812.         if (Xdebug)
  1813.         printf("ok1 "), fflush(stdout);
  1814.         ++Incfile->lineno;
  1815.         parse(buf);
  1816.         if (Xdebug)
  1817.         printf("ok2 "), fflush(stdout);
  1818.         if (Av[1][0]) {
  1819.         findext(Av[1]);
  1820.         if (mne = findmne(Av[1])) {
  1821.             if ((mne->flags & MF_IF) || (Ifstack->true && Ifstack->acctrue))
  1822.             (*mne->vect)(Av[2], mne);
  1823.         } else {
  1824.             if (Ifstack->true && Ifstack->acctrue) {
  1825.             printf("unknown mnemonic: '%s'\n", Av[1]);
  1826.             asmerr(4,0);
  1827.             }
  1828.         }
  1829.         } else {
  1830.         if (Ifstack->true && Ifstack->acctrue)
  1831.             programlabel();
  1832.         }
  1833.         if (Xdebug)
  1834.         printf("ok3 "), fflush(stdout);
  1835.         if (F_listfile && ListMode)
  1836.         outlistfile(comment);
  1837.     }
  1838.     while (Reploop && Reploop->file == Incfile)
  1839.         rmnode(&Reploop, sizeof(REPLOOP));
  1840.     while (Ifstack->file == Incfile)
  1841.         rmnode(&Ifstack, sizeof(IFSTACK));
  1842.     fclose(Incfile->fi);
  1843.     free(Incfile->name);
  1844.     --Inclevel;
  1845.     rmnode(&Incfile, sizeof(INCFILE));
  1846.     if (Incfile) {
  1847.         /*
  1848.         if (F_verbose > 1)
  1849.         printf("back to: %s\n", Incfile->name);
  1850.         */
  1851.         if (F_listfile)
  1852.         fprintf(FI_listfile, "------- FILE %s\n", Incfile->name);
  1853.     }
  1854.     }
  1855.     if (F_verbose >= 1) {
  1856.     SEGMENT *seg;
  1857.     char *bss;
  1858.  
  1859.     puts("");
  1860.     printf("END OF PASS: %d\n", pass);
  1861.     puts("Segment---     init-pc  init-rpc finl-pc  finl-rpc");
  1862.     for (seg = Seglist; seg; seg = seg->next) {
  1863.         bss = (seg->flags & SF_BSS) ? "[u]" : "   ";
  1864.         printf("%10s %3s ", seg->name, bss);
  1865.         printf("%s %s ", sftos(seg->initorg, seg->initflags), sftos(seg->initrorg, seg->initrflags));
  1866.         printf("%s %s\n", sftos(seg->org, seg->flags), sftos(seg->rorg, seg->rflags));
  1867.     }
  1868.     printf("Reasons: %4ld,%4ld   Reasoncode: %08lx\n", Redo, Redo_eval, Redo_why);
  1869.     }
  1870.     if (F_verbose >= 3) {
  1871.     SYMBOL *sym;
  1872.     short i;
  1873.     short j = 0;
  1874.  
  1875.     if (F_verbose == 3)
  1876.         puts("SYMBOLIST:  (Unresolved symbols only)");
  1877.     else
  1878.         puts("SYMBOLIST");
  1879.     for (i = 0; i < SHASHSIZE; ++i) {
  1880.         for (sym = SHash[i]; sym; sym = sym->next) {
  1881.         if (F_verbose > 3 || (sym->flags & SYM_UNKNOWN)) {
  1882.             printf("%10s %s\n", sym->name, sftos(sym->value, sym->flags));
  1883.             j = 1;
  1884.         }
  1885.         }
  1886.     }
  1887.     if (j == 0)
  1888.         puts("NO SYMBOLS");
  1889.     else
  1890.         puts("ENDSYMBOLIST");
  1891.     }
  1892.     closegenerate();
  1893.     fclose(FI_temp);
  1894.     if (FI_listfile)
  1895.     fclose(FI_listfile);
  1896.     if (Redo) {
  1897.     if (Redo == oldredo && Redo_why == oldwhy && Redo_eval == oldeval) {
  1898.         puts("Error: source is not resolvable.");
  1899.         if (F_verbose < 2)
  1900.         puts("re-run with verbose option 2 or higher to determine problem");
  1901.         exit(1);
  1902.     }
  1903.     oldredo = Redo;
  1904.     oldwhy = Redo_why;
  1905.     oldeval = Redo_eval;
  1906.     Redo = 0;
  1907.     Redo_why = 0;
  1908.     Redo_eval = 0;
  1909.     ++pass;
  1910.     if (StopAtEnd) {
  1911.         printf("Unrecoverable error in pass, aborting assembly!\n");
  1912.     } else if (pass > 10) {
  1913.         printf("More than 10 passes, something *must* be wrong!\n");
  1914.         exit(1);
  1915.     } else {
  1916.         clearrefs();
  1917.         clearsegs();
  1918.         goto nextpass;
  1919.     }
  1920.     }
  1921.     if (F_symfile) {
  1922.     FILE *fi = fopen(F_symfile, "w");
  1923.     if (fi) {
  1924.         register SYMBOL *sym;
  1925.         puts("dumping symbols...");
  1926.         for (i = 0; i < SHASHSIZE; ++i) {
  1927.         for (sym = SHash[i]; sym; sym = sym->next) {
  1928.             fprintf(fi, "%-15s %s", sym->name, sftos(sym->value, sym->flags));
  1929.             if (sym->flags & SYM_STRING)
  1930.             fprintf(fi, " \"%s\"", sym->string);
  1931.             putc('\n', fi);
  1932.         }
  1933.         }
  1934.         fclose(fi);
  1935.     } else {
  1936.         printf("unable to open symbol dump file '%s'\n", F_symfile);
  1937.     }
  1938.     }
  1939. }
  1940.  
  1941. static
  1942. outlistfile(comment)
  1943. char *comment;
  1944. {
  1945.     extern ubyte Gen[];
  1946.     extern short Glen;
  1947.     char c = (Pflags & SF_BSS) ? 'U' : ' ';
  1948.     static char buf1[MAXLINE+32];
  1949.     static char buf2[MAXLINE+32];
  1950.     ubyte *ptr = Extstr;
  1951.     char *dot = "";
  1952.     register int i, j;
  1953.  
  1954.     if (ptr)
  1955.     dot = ".";
  1956.     else
  1957.     ptr = (ubyte *)"";
  1958.  
  1959.     sprintf(buf1, "%6ld %c%s", Incfile->lineno, c, sftos(Plab, Pflags & 7));
  1960.     j = strlen(buf1);
  1961.     for (i = 0; i < Glen && i < 4; ++i, j += 3)
  1962.     sprintf(buf1+j, "%02x ", Gen[i]);
  1963.     if (i < Glen && i == 4)
  1964.     buf1[j-1] = '*';
  1965.     for (; i < 4; ++i) {
  1966.     buf1[j] = buf1[j+1] = buf1[j+2] = ' ';
  1967.     j += 3;
  1968.     }
  1969.     sprintf(buf1+j, "%-10s  %s%s%s\011%s\n", Av[0], Av[1], dot, ptr, Av[2]);
  1970.     if (comment[0]) { /*  tab and comment */
  1971.     j = strlen(buf1) - 1;
  1972.     sprintf(buf1+j, "\011;%s", comment);
  1973.     }
  1974.     fwrite(buf2, tabit(buf1,buf2), 1, FI_listfile);
  1975.     Glen = 0;
  1976.     Extstr = NULL;
  1977. }
  1978.  
  1979. tabit(buf1, buf2)
  1980. char *buf1, *buf2;
  1981. {
  1982.     register char *bp, *ptr;
  1983.     register short j, k;
  1984.  
  1985.     bp = buf2;
  1986.     ptr= buf1;
  1987.     for (j = 0; *ptr; ++ptr, ++bp, j = (j+1)&7) {
  1988.     *bp = *ptr;
  1989.     if (*ptr == 9)
  1990.         j = 0;
  1991.     if (j == 7 && *bp == ' ' && *(bp-1) == ' ') {
  1992.         k = j;
  1993.         while (k-- >= 0 && *bp == ' ')
  1994.         --bp;
  1995.         *++bp = 9;
  1996.     }
  1997.     }
  1998.     while (bp != buf2 && bp[-1] == ' ' || bp[-1] == 9)
  1999.     --bp;
  2000.     *bp = *ptr;
  2001.     return((int)(bp - buf2));
  2002. }
  2003.  
  2004.  
  2005. ubyte *
  2006. sftos(val, flags)
  2007. long val;
  2008. short flags;
  2009. {
  2010.     static char buf[64];
  2011.     static char c;
  2012.     register char *ptr = (c) ? buf : buf + 32;
  2013.  
  2014.     c = 1 - c;
  2015.     sprintf(ptr, "%04lx", val);
  2016.     if (flags & SYM_UNKNOWN)
  2017.     strcpy(ptr, "????");
  2018.     if (flags & SYM_STRING)
  2019.     strcpy(ptr, "str ");
  2020.     if (flags & SYM_MACRO)
  2021.     strcpy(ptr, "eqm ");
  2022.     strcpy(ptr+4, "    ");
  2023.     if (flags & (SYM_MASREF|SYM_SET)) {
  2024.     ptr[4] = '(';
  2025.     ptr[7] = ')';
  2026.     }
  2027.     if (flags & (SYM_MASREF))
  2028.     ptr[5] = 'r';
  2029.     if (flags & (SYM_SET))
  2030.     ptr[6] = 's';
  2031.     return((ubyte *)ptr);
  2032. }
  2033.  
  2034. void
  2035. clearsegs()
  2036. {
  2037.     register SEGMENT *seg;
  2038.  
  2039.     for (seg = Seglist; seg; seg = seg->next) {
  2040.     seg->flags = (seg->flags & SF_BSS) | SF_UNKNOWN;
  2041.     seg->rflags= seg->initflags = seg->initrflags = SF_UNKNOWN;
  2042.     }
  2043. }
  2044.  
  2045. void
  2046. clearrefs()
  2047. {
  2048.     register SYMBOL *sym;
  2049.     register short i;
  2050.  
  2051.     for (i = 0; i < SHASHSIZE; ++i)
  2052.     for (sym = SHash[i]; sym; sym = sym->next)
  2053.         sym->flags &= ~SYM_REF;
  2054. }
  2055.  
  2056. static
  2057. char *
  2058. cleanup(buf)
  2059. register ubyte *buf;
  2060. {
  2061.     register ubyte *str;
  2062.     register STRLIST *strlist;
  2063.     register short arg, add;
  2064.     char *comment = "";
  2065.  
  2066.     for (str = buf; *str; ++str) {
  2067.     switch(*str) {
  2068.     case ';':
  2069.         comment = (char *)str + 1;
  2070.         /*    FALL THROUGH    */
  2071.     case '\r':
  2072.     case '\n':
  2073.         goto br2;
  2074.     case TAB:
  2075.         *str = ' ';
  2076.         break;
  2077.     case '\'':
  2078.         ++str;
  2079.         if (*str == TAB)
  2080.         *str = ' ';
  2081.         if (*str == '\n' || *str == 0) {
  2082.         str[0] = ' ';
  2083.         str[1] = 0;
  2084.         }
  2085.         if (str[0] == ' ')
  2086.         str[0] = 0x80;
  2087.         break;
  2088.     case '\"':
  2089.         ++str;
  2090.         while (*str && *str != '\"') {
  2091.         if (*str == ' ')
  2092.             *str = 0x80;
  2093.         ++str;
  2094.         }
  2095.         if (*str != '\"') {
  2096.         asmerr(0,0);
  2097.         --str;
  2098.         }
  2099.         break;
  2100.     case '{':
  2101.         if (Disable_me)
  2102.         break;
  2103.         if (Xdebug)
  2104.         printf("macro tail: '%s'\n", str);
  2105.         arg = atoi(str+1);
  2106.         for (add = 0; *str && *str != '}'; ++str)
  2107.         --add;
  2108.         if (*str != '}') {
  2109.         puts("end brace required");
  2110.         --str;
  2111.         break;
  2112.         }
  2113.         --add;
  2114.         ++str;
  2115.         if (Xdebug)
  2116.         printf("add/str: %d '%s'\n", add, str);
  2117.         for (strlist = Incfile->args; arg && strlist;) {
  2118.         --arg;
  2119.         strlist = strlist->next;
  2120.         }
  2121.         if (strlist) {
  2122.         add += strlen(strlist->buf);
  2123.         if (Xdebug)
  2124.             printf("strlist: '%s' %d\n", strlist->buf, strlen(strlist->buf));
  2125.         if (str + add + strlen(str) + 1 > buf + MAXLINE) {
  2126.             if (Xdebug)
  2127.             printf("str %8ld buf %8ld (add/strlen(str)): %d %ld\n", str, buf, add, strlen(str));
  2128.             panic("failure1");
  2129.         }
  2130.         bmov(str, str + add, strlen(str)+1);
  2131.         str += add;
  2132.         if (str - strlen(strlist->buf) < buf)
  2133.             panic("failure2");
  2134.         bmov(strlist->buf, str - strlen(strlist->buf), strlen(strlist->buf));
  2135.         str -= strlen(strlist->buf);
  2136.         if (str < buf || str >= buf + MAXLINE)
  2137.             panic("failure 3");
  2138.         --str;    /*  for loop increments string    */
  2139.         } else {
  2140.         asmerr(7,0);
  2141.         goto br2;
  2142.         }
  2143.         break;
  2144.     }
  2145.     }
  2146. br2:
  2147.     while(str != buf && *(str-1) == ' ')
  2148.     --str;
  2149.     *str = 0;
  2150.     return(comment);
  2151. }
  2152.  
  2153. panic(str)
  2154. char *str;
  2155. {
  2156.     puts(str);
  2157.     exit(1);
  2158. }
  2159.  
  2160. /*
  2161.  *  .dir    direct            x
  2162.  *  .ext    extended            x
  2163.  *  .r        relative            x
  2164.  *  .x        index, no offset        x
  2165.  *  .x8     index, byte offset        x
  2166.  *  .x16    index, word offset        x
  2167.  *  .bit    bit set/clr
  2168.  *  .bbr    bit and branch
  2169.  *  .imp    implied (inherent)      x
  2170.  *  .b                    x
  2171.  *  .w                    x
  2172.  *  .l                    x
  2173.  *  .u                    x
  2174.  */
  2175.  
  2176.  
  2177. void
  2178. findext(str)
  2179. register ubyte *str;
  2180. {
  2181.     Mnext = -1;
  2182.     Extstr = NULL;
  2183.     while (*str && *str != '.')
  2184.     ++str;
  2185.     if (*str) {
  2186.     *str = 0;
  2187.     ++str;
  2188.     Extstr = str;
  2189.     switch(str[0]|0x20) {
  2190.     case '0':
  2191.     case 'i':
  2192.         Mnext = AM_IMP;
  2193.         switch(str[1]|0x20) {
  2194.         case 'x':
  2195.         Mnext = AM_0X;
  2196.         break;
  2197.         case 'y':
  2198.         Mnext = AM_0Y;
  2199.         break;
  2200.         case 'n':
  2201.         Mnext = AM_INDWORD;
  2202.         break;
  2203.         }
  2204.         return;
  2205.     case 'd':
  2206.     case 'b':
  2207.     case 'z':
  2208.         switch(str[1]|0x20) {
  2209.         case 'x':
  2210.         Mnext = AM_BYTEADRX;
  2211.         break;
  2212.         case 'y':
  2213.         Mnext = AM_BYTEADRY;
  2214.         break;
  2215.         case 'i':
  2216.         Mnext = AM_BITMOD;
  2217.         break;
  2218.         case 'b':
  2219.         Mnext = AM_BITBRAMOD;
  2220.         break;
  2221.         default:
  2222.         Mnext = AM_BYTEADR;
  2223.         break;
  2224.         }
  2225.         return;
  2226.     case 'e':
  2227.     case 'w':
  2228.     case 'a':
  2229.         switch(str[1]|0x20) {
  2230.         case 'x':
  2231.         Mnext = AM_WORDADRX;
  2232.         break;
  2233.         case 'y':
  2234.         Mnext = AM_WORDADRY;
  2235.         break;
  2236.         default:
  2237.         Mnext = AM_WORDADR;
  2238.         break;
  2239.         }
  2240.         return;
  2241.     case 'l':
  2242.         Mnext = AM_LONG;
  2243.         return;
  2244.     case 'r':
  2245.         Mnext = AM_REL;
  2246.         return;
  2247.     case 'u':
  2248.         Mnext = AM_BSS;
  2249.         return;
  2250.     }
  2251.     }
  2252. }
  2253.  
  2254. /*
  2255.  *  bytes arg will eventually be used to implement a linked list of free
  2256.  *  nodes.
  2257.  */
  2258.  
  2259. rmnode(base, bytes)
  2260. ulong **base;
  2261. {
  2262.     ulong *node;
  2263.  
  2264.     if (node = *base) {
  2265.     *base = *(ulong **)node;
  2266.     free(node);
  2267.     }
  2268. }
  2269.  
  2270. /*
  2271.  *  Parse into three arguments: Av[0], Av[1], Av[2]
  2272.  */
  2273.  
  2274. parse(buf)
  2275. register ubyte *buf;
  2276. {
  2277.     register short i, j;
  2278.  
  2279.     i = j = 0;
  2280.     Av[0] = Avbuf;
  2281.     while (buf[i] && buf[i] != ' ') {
  2282.     if (buf[i] == 0x80)
  2283.         buf[i] = ' ';
  2284.     Avbuf[j++] = buf[i++];
  2285.     }
  2286.     Avbuf[j++] = 0;
  2287.     while (buf[i] == ' ')
  2288.     ++i;
  2289.     Av[1] = Avbuf + j;
  2290.     while (buf[i] && buf[i] != ' ') {
  2291.     if (buf[i] == 0x80)
  2292.         buf[i] = ' ';
  2293.     Avbuf[j++] = buf[i++];
  2294.     }
  2295.     Avbuf[j++] = 0;
  2296.     while (buf[i] == ' ')
  2297.     ++i;
  2298.     Av[2] = Avbuf + j;
  2299.     while (buf[i]) {
  2300.     if (buf[i] == ' ') {
  2301.         while(buf[i+1] == ' ')
  2302.         ++i;
  2303.     }
  2304.     if (buf[i] == 0x80)
  2305.         buf[i] = ' ';
  2306.     Avbuf[j++] = buf[i++];
  2307.     }
  2308.     Avbuf[j] = 0;
  2309. }
  2310.  
  2311.  
  2312.  
  2313. MNE *
  2314. findmne(str)
  2315. register ubyte *str;
  2316. {
  2317.     register uword i;
  2318.     register ubyte c;
  2319.     register MNE *mne;
  2320.     ubyte buf[128];
  2321.  
  2322.     for (i = 0; c = str[i]; ++i) {
  2323.     if (c >= 'A' && c <= 'Z')
  2324.         c += 'a' - 'A';
  2325.     buf[i] = c;
  2326.     }
  2327.     buf[i] = 0;
  2328.     for (mne = MHash[hash1(buf)]; mne; mne = mne->next) {
  2329.     if (strcmp(buf, mne->name) == 0)
  2330.         break;
  2331.     }
  2332.     return(mne);
  2333. }
  2334.  
  2335. v_macro(str)
  2336. char *str;
  2337. {
  2338.     extern void v_execmac();
  2339.     extern void v_endm();
  2340.     STRLIST *base;
  2341.     ubyte defined = 0;
  2342.     register STRLIST **slp, *sl;
  2343.     register MACRO *mac;
  2344.     register MNE   *mne;
  2345.     register uword i;
  2346.     ubyte buf[MAXLINE];
  2347.     ubyte skipit = !(Ifstack->true && Ifstack->acctrue);
  2348.  
  2349.     if (skipit) {
  2350.     defined = 1;
  2351.     } else {
  2352.     defined = (findmne(str) != NULL);
  2353.     if (F_listfile && ListMode)
  2354.         outlistfile("");
  2355.     }
  2356.     if (!defined) {
  2357.     base = NULL;
  2358.     slp = &base;
  2359.     mac = (MACRO *)permalloc(sizeof(MACRO));
  2360.     i = hash1(str);
  2361.     mac->next = (MACRO *)MHash[i];
  2362.     mac->vect = v_execmac;
  2363.     mac->name = strcpy(permalloc(strlen(str)+1), str);
  2364.     mac->flags = MF_MACRO;
  2365.     MHash[i] = (MNE *)mac;
  2366.     }
  2367.     while (fgets(buf, MAXLINE, Incfile->fi)) {
  2368.     char *comment;
  2369.  
  2370.     if (Xdebug)
  2371.         printf("%08lx %s\n", Incfile, buf);
  2372.     ++Incfile->lineno;
  2373.     Disable_me = 1;
  2374.     comment = cleanup(buf);
  2375.     Disable_me = 0;
  2376.     if (parse(buf), Av[1][0]) {
  2377.         findext(Av[1]);
  2378.         mne = findmne(Av[1]);
  2379.         if (mne->vect == v_endm) {
  2380.         if (!defined)
  2381.             mac->strlist = base;
  2382.         return;
  2383.         }
  2384.     }
  2385.     if (Xdebug)
  2386.         printf("ok1"), fflush(stdout);
  2387.     if (!skipit && F_listfile && ListMode)
  2388.         outlistfile(comment);
  2389.     if (Xdebug)
  2390.         printf("ok2"), fflush(stdout);
  2391.     if (!defined) {
  2392.         sl = (STRLIST *)permalloc(5+strlen(buf));
  2393.         strcpy(sl->buf, buf);
  2394.         *slp = sl;
  2395.         slp = &sl->next;
  2396.     }
  2397.     if (Xdebug)
  2398.         printf("ok3\n"), fflush(stdout);
  2399.     }
  2400.     asmerr(8,1);
  2401. }
  2402.  
  2403. addhashtable(mne)
  2404. MNE *mne;
  2405. {
  2406.     register uword i, j;
  2407.     uword opcode[NUMOC];
  2408.  
  2409.     for (; mne->vect; ++mne) {
  2410.     bmov(mne->opcode, opcode, sizeof(mne->opcode));
  2411.     for (i = j = 0; i < NUMOC; ++i) {
  2412.         mne->opcode[i] = 0;     /* not really needed */
  2413.         if (mne->okmask & (1L << i))
  2414.         mne->opcode[i] = opcode[j++];
  2415.     }
  2416.     i = hash1(mne->name);
  2417.     mne->next = MHash[i];
  2418.     MHash[i] = mne;
  2419.     }
  2420. }
  2421.  
  2422.  
  2423. static uword
  2424. hash1(str)
  2425. register ubyte *str;
  2426. {
  2427.     register uword result = 0;
  2428.  
  2429.     while (*str)
  2430.     result = (result << 2) ^ *str++;
  2431.     return(result & MHASHAND);
  2432. }
  2433.  
  2434. pushinclude(str)
  2435. char *str;
  2436. {
  2437.     register INCFILE *inf;
  2438.     register FILE *fi;
  2439.  
  2440.     if (fi = fopen(str, "r")) {
  2441.     if (F_verbose > 1) {
  2442. #ifdef IBM
  2443.         printf(" Include: %s\n", str);
  2444. #else
  2445.         printf("%.*sInclude: %s\n", Inclevel*4, "", str);
  2446. #endif
  2447.     }
  2448.     ++Inclevel;
  2449.     if (F_listfile)
  2450.         fprintf(FI_listfile, "------- FILE %s\n", str);
  2451.     inf = (INCFILE *)zmalloc(sizeof(INCFILE));
  2452.     inf->next   = Incfile;
  2453.     inf->name   = strcpy(malloc(strlen(str)+1), str);
  2454.     inf->fi     = fi;
  2455.     inf->lineno = 0;
  2456.     Incfile = inf;
  2457.     return(1);
  2458.     }
  2459.     printf("unable to open %s\n", str);
  2460. }
  2461.  
  2462. char Stopend[] = {
  2463.     1,1,1,1,1,1,1,1,1,1,0,1,1,0,1,1,1,0,0,1,1
  2464. };
  2465.  
  2466. char *Errors[] = {
  2467.     "Syntax Error",
  2468.     "Expression table overflow",
  2469.     "Unbalanced Braces []",
  2470.     "Division by zero",
  2471.     "Unknown Mnemonic",
  2472.     "Illegal Addressing mode",
  2473.     "Illegal forced Addressing mode",   /*  nu  */
  2474.     "Not enough args passed to Macro",
  2475.     "Premature EOF",
  2476.     "Illegal character",
  2477.     "Branch out of range",
  2478.     "ERR pseudo-op encountered",
  2479.     "Origin Reverse-indexed",           /*  12  */
  2480.     "EQU: Value mismatch",
  2481.     "Address must be <$100",            /*  nu  */
  2482.     "Illegal bit specification",
  2483.     "Not enough args",                  /*  16  */
  2484.     "Label Mismatch",                   /*  17  */
  2485.     "Value Undefined",
  2486.     "Illegal Forced Address mode",      /*  19  */
  2487.     "Processor not supported",          /*  20  */
  2488.     NULL
  2489. };
  2490.  
  2491. asmerr(err, abort)
  2492. short err, abort;
  2493. {
  2494.     ubyte *ptr;
  2495.     ubyte *str;
  2496.     INCFILE *incfile;
  2497.  
  2498.     if (Stopend[err])
  2499.     StopAtEnd = 1;
  2500.     for (incfile = Incfile; incfile->flags & INF_MACRO; incfile=incfile->next);
  2501.     str = (ubyte *)Errors[err];
  2502.     if (F_listfile)
  2503.     fprintf(FI_listfile, "*line %4ld %-10s %s\n", incfile->lineno, incfile->name, str);
  2504.     printf("line %4ld %-10s %s\n", incfile->lineno, incfile->name, str);
  2505.     if (abort) {
  2506.     puts("Aborting assembly");
  2507.     if (F_listfile)
  2508.         fputs("Aborting assembly\n", FI_listfile);
  2509.     exit(1);
  2510.     }
  2511. }
  2512.  
  2513. ubyte *
  2514. zmalloc(bytes)
  2515. uword bytes;
  2516. {
  2517.     ubyte *ptr = malloc(bytes);
  2518.     if (ptr) {
  2519.     bzero(ptr, bytes);
  2520.     return(ptr);
  2521.     }
  2522.     panic("unable to malloc");
  2523. }
  2524.  
  2525. ubyte *
  2526. permalloc(bytes)
  2527. uword bytes;
  2528. {
  2529.     static ubyte *buf;
  2530.     static int left;
  2531.     ubyte *ptr;
  2532.  
  2533.     bytes = (bytes + 1) & ~1;
  2534.     if (bytes > left) {
  2535.     if ((buf = malloc(ALLOCSIZE)) == NULL)
  2536.         panic("unable to malloc");
  2537.     bzero(buf, ALLOCSIZE);
  2538.     left = ALLOCSIZE;
  2539.     if (bytes > left)
  2540.         panic("software error");
  2541.     }
  2542.     ptr = buf;
  2543.     buf += bytes;
  2544.     left -= bytes;
  2545.     return(ptr);
  2546. }
  2547.  
  2548.  
  2549. #ifdef UNIX
  2550. xbset(s,n,c)
  2551. register ubyte *s;
  2552. register ulong n;
  2553. register ubyte c;
  2554. {
  2555.     while (n--)
  2556.     *s++ = c;
  2557. }
  2558. #endif
  2559.  
  2560. #ifdef IBM
  2561. bcmp(s,d,n)
  2562. ubyte *s, *d;
  2563. uword n;
  2564. {
  2565.     uword i;
  2566.     for (i = 0; i < n; ++i) {
  2567.     if (s[i] != d[i])
  2568.         return(0);
  2569.     }
  2570.     return(1);
  2571. }
  2572.  
  2573. #endif
  2574.  
  2575.  
  2576.  
  2577. \Rogue\Monster\
  2578. else
  2579.   echo "will not over write src/main.c"
  2580. fi
  2581. if [ `wc -c src/main.c | awk '{printf $1}'` -ne 19306 ]
  2582. then
  2583. echo `wc -c src/main.c | awk '{print "Got " $1 ", Expected " 19306}'`
  2584. fi
  2585. echo "Finished archive 2 of 3"
  2586. # if you want to concatenate archives, remove anything after this line
  2587. exit
  2588. -- 
  2589. Bob Page, U of Lowell CS Dept.  page@swan.ulowell.edu  ulowell!page
  2590. Have five nice days.
  2591.